1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 86, 87, 93, 94, 95 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, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
33 Lisp_Object Qwindowp
, Qwindow_live_p
;
35 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
36 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
38 void delete_all_subwindows ();
39 static struct window
*decode_window();
41 /* This is the window in which the terminal's cursor should
42 be left when nothing is being done with it. This must
43 always be a leaf window, and its buffer is selected by
44 the top level editing loop at the end of each command.
46 This value is always the same as
47 FRAME_SELECTED_WINDOW (selected_frame). */
49 Lisp_Object selected_window
;
51 /* The minibuffer window of the selected frame.
52 Note that you cannot test for minibufferness of an arbitrary window
53 by comparing against this; but you can test for minibufferness of
54 the selected window. */
55 Lisp_Object minibuf_window
;
57 /* Non-nil means it is the window for C-M-v to scroll
58 when the minibuffer is selected. */
59 Lisp_Object Vminibuf_scroll_window
;
61 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
62 Lisp_Object Vother_window_scroll_buffer
;
64 /* Non-nil means it's function to call to display temp buffers. */
65 Lisp_Object Vtemp_buffer_show_function
;
67 /* If a window gets smaller than either of these, it is removed. */
68 int window_min_height
;
71 /* Nonzero implies Fdisplay_buffer should create windows. */
74 /* Nonzero implies make new frames for Fdisplay_buffer. */
77 /* Non-nil means use this function instead of default */
78 Lisp_Object Vpop_up_frame_function
;
80 /* Function to call to handle Fdisplay_buffer. */
81 Lisp_Object Vdisplay_buffer_function
;
83 /* List of buffer *names* for buffers that should have their own frames. */
84 Lisp_Object Vspecial_display_buffer_names
;
86 /* List of regexps for buffer names that should have their own frames. */
87 Lisp_Object Vspecial_display_regexps
;
89 /* Function to pop up a special frame. */
90 Lisp_Object Vspecial_display_function
;
92 /* List of buffer *names* for buffers to appear in selected window. */
93 Lisp_Object Vsame_window_buffer_names
;
95 /* List of regexps for buffer names to appear in selected window. */
96 Lisp_Object Vsame_window_regexps
;
98 /* Hook run at end of temp_output_buffer_show. */
99 Lisp_Object Qtemp_buffer_show_hook
;
101 /* Fdisplay_buffer always splits the largest window
102 if that window is more than this high. */
103 int split_height_threshold
;
105 /* Number of lines of continuity in scrolling by screenfuls. */
106 int next_screen_context_lines
;
108 /* Incremented for each window created. */
109 static int sequence_number
;
111 #define min(a, b) ((a) < (b) ? (a) : (b))
113 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
115 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
116 "Returns t if OBJECT is a window.")
120 return WINDOWP (object
) ? Qt
: Qnil
;
123 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
124 "Returns t if OBJECT is a window which is currently visible.")
128 return (WINDOWP (object
) && ! NILP (XWINDOW (object
)->buffer
) ? Qt
: Qnil
);
135 register struct window
*p
;
136 register struct Lisp_Vector
*vec
;
139 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct window
));
140 for (i
= 0; i
< VECSIZE (struct window
); i
++)
141 vec
->contents
[i
] = Qnil
;
142 vec
->size
= VECSIZE (struct window
);
143 p
= (struct window
*)vec
;
144 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
145 XSETFASTINT (p
->left
, 0);
146 XSETFASTINT (p
->top
, 0);
147 XSETFASTINT (p
->height
, 0);
148 XSETFASTINT (p
->width
, 0);
149 XSETFASTINT (p
->hscroll
, 0);
150 XSETFASTINT (p
->last_point_x
, 0);
151 XSETFASTINT (p
->last_point_y
, 0);
152 p
->start
= Fmake_marker ();
153 p
->pointm
= Fmake_marker ();
154 XSETFASTINT (p
->use_time
, 0);
156 p
->display_table
= Qnil
;
162 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
163 "Return the window that the cursor now appears in and commands apply to.")
166 return selected_window
;
169 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
170 "Return the window used now for minibuffers.\n\
171 If the optional argument FRAME is specified, return the minibuffer window\n\
172 used by that frame.")
178 XSETFRAME (frame
, selected_frame
);
180 CHECK_LIVE_FRAME (frame
, 0);
183 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
186 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
187 "Returns non-nil if WINDOW is a minibuffer window.")
191 struct window
*w
= decode_window (window
);
192 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
195 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
196 Spos_visible_in_window_p
, 0, 2, 0,
197 "Return t if position POS is currently on the frame in WINDOW.\n\
198 Returns nil if that position is scrolled vertically out of view.\n\
199 POS defaults to point; WINDOW, to the selected window.")
201 Lisp_Object pos
, window
;
203 register struct window
*w
;
207 register struct buffer
*buf
;
208 struct position posval
;
215 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
219 w
= decode_window (window
);
220 top
= marker_position (w
->start
);
221 hscroll
= XINT (w
->hscroll
);
226 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
228 buf
= XBUFFER (w
->buffer
);
229 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
231 /* If frame is up to date,
232 use the info recorded about how much text fit on it. */
233 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
234 || (XFASTINT (w
->window_end_vpos
) < height
))
240 if (posint
> BUF_ZV (buf
))
243 /* w->start can be out of range. If it is, do something reasonable. */
244 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
247 /* If that info is not correct, calculate afresh */
248 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0), 0,
250 window_internal_width (w
) - 1,
253 return posval
.vpos
< height
? Qt
: Qnil
;
257 static struct window
*
258 decode_window (window
)
259 register Lisp_Object window
;
262 return XWINDOW (selected_window
);
264 CHECK_LIVE_WINDOW (window
, 0);
265 return XWINDOW (window
);
268 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
269 "Return the buffer that WINDOW is displaying.")
273 return decode_window (window
)->buffer
;
276 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
277 "Return the number of lines in WINDOW (including its mode line).")
281 return decode_window (window
)->height
;
284 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
285 "Return the number of display columns in WINDOW.\n\
286 This is the width that is usable columns available for text in WINDOW.\n\
287 If you want to find out how many columns WINDOW takes up,\n\
288 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
292 return make_number (window_internal_width (decode_window (window
)));
295 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
296 "Return the number of columns by which WINDOW is scrolled from left margin.")
300 return decode_window (window
)->hscroll
;
303 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
304 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
305 NCOL should be zero or positive.")
307 register Lisp_Object window
, ncol
;
309 register struct window
*w
;
311 CHECK_NUMBER (ncol
, 1);
312 if (XINT (ncol
) < 0) XSETFASTINT (ncol
, 0);
313 w
= decode_window (window
);
314 if (XINT (w
->hscroll
) != XINT (ncol
))
315 XBUFFER (w
->buffer
)->clip_changed
= 1; /* Prevent redisplay shortcuts */
320 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
321 Swindow_redisplay_end_trigger
, 0, 1, 0,
322 "Return WINDOW's redisplay end trigger value.\n\
323 See `set-window-redisplay-end-trigger' for more information.")
327 return decode_window (window
)->redisplay_end_trigger
;
330 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
331 Sset_window_redisplay_end_trigger
, 2, 2, 0,
332 "Set WINDOW's redisplay end trigger value to VALUE.\n\
333 VALUE should be a buffer position (typically a marker) or nil.\n\
334 If it is a buffer position, then if redisplay in WINDOW reaches a position\n\
335 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called\n\
336 with two arguments: WINDOW, and the end trigger value.\n\
337 Afterwards the end-trigger value is reset to nil.")
339 register Lisp_Object window
, value
;
341 register struct window
*w
;
343 w
= decode_window (window
);
344 w
->redisplay_end_trigger
= value
;
348 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
349 "Return a list of the edge coordinates of WINDOW.\n\
350 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
351 RIGHT is one more than the rightmost column used by WINDOW,\n\
352 and BOTTOM is one more than the bottommost row used by WINDOW\n\
357 register struct window
*w
= decode_window (window
);
359 return Fcons (w
->left
, Fcons (w
->top
,
360 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
361 Fcons (make_number (XFASTINT (w
->top
)
362 + XFASTINT (w
->height
)),
366 /* Test if the character at column *x, row *y is within window *w.
367 If it is not, return 0;
368 if it is in the window's text area,
369 set *x and *y to its location relative to the upper left corner
372 if it is on the window's modeline, return 2;
373 if it is on the border between the window and its right sibling,
376 coordinates_in_window (w
, x
, y
)
377 register struct window
*w
;
380 register int left
= XINT (w
->left
);
381 register int width
= XINT (w
->width
);
382 register int window_height
= XINT (w
->height
);
383 register int top
= XFASTINT (w
->top
);
385 if ( *x
< left
|| *x
>= left
+ width
386 || *y
< top
|| *y
>= top
+ window_height
)
389 /* Is the character is the mode line? */
390 if (*y
== top
+ window_height
- 1
391 && ! MINI_WINDOW_P (w
))
394 /* Is the character in the right border? */
395 if (*x
== left
+ width
- 1
396 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
404 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
405 Scoordinates_in_window_p
, 2, 2, 0,
406 "Return non-nil if COORDINATES are in WINDOW.\n\
407 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
408 measured in characters from the upper-left corner of the frame.\n\
409 (0 . 0) denotes the character in the upper left corner of the\n\
411 If COORDINATES are in the text portion of WINDOW,\n\
412 the coordinates relative to the window are returned.\n\
413 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
414 If they are on the border between WINDOW and its right sibling,\n\
415 `vertical-line' is returned.")
416 (coordinates
, window
)
417 register Lisp_Object coordinates
, window
;
421 CHECK_LIVE_WINDOW (window
, 0);
422 CHECK_CONS (coordinates
, 1);
423 x
= XINT (Fcar (coordinates
));
424 y
= XINT (Fcdr (coordinates
));
426 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
428 case 0: /* NOT in window at all. */
431 case 1: /* In text part of window. */
434 case 2: /* In mode line of window. */
437 case 3: /* On right border of window. */
438 return Qvertical_line
;
445 /* Find the window containing column x, row y, and return it as a
446 Lisp_Object. If x, y is on the window's modeline, set *part
447 to 1; if it is on the separating line between the window and its
448 right sibling, set it to 2; otherwise set it to 0. If there is no
449 window under x, y return nil and leave *part unmodified. */
451 window_from_coordinates (frame
, x
, y
, part
)
456 register Lisp_Object tem
, first
;
458 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
462 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
470 tem
= Fnext_window (tem
, Qt
, Qlambda
);
472 while (! EQ (tem
, first
));
477 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
478 "Return window containing coordinates X and Y on FRAME.\n\
479 If omitted, FRAME defaults to the currently selected frame.\n\
480 The top left corner of the frame is considered to be row 0,\n\
483 Lisp_Object x
, y
, frame
;
489 XSETFRAME (frame
, selected_frame
);
491 CHECK_LIVE_FRAME (frame
, 2);
496 return window_from_coordinates (XFRAME (frame
),
501 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
502 "Return current value of point in WINDOW.\n\
503 For a nonselected window, this is the value point would have\n\
504 if that window were selected.\n\
506 Note that, when WINDOW is the selected window and its buffer\n\
507 is also currently selected, the value returned is the same as (point).\n\
508 It would be more strictly correct to return the `top-level' value\n\
509 of point, outside of any save-excursion forms.\n\
510 But that is hard to define.")
514 register struct window
*w
= decode_window (window
);
516 if (w
== XWINDOW (selected_window
)
517 && current_buffer
== XBUFFER (w
->buffer
))
519 return Fmarker_position (w
->pointm
);
522 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
523 "Return position at which display currently starts in WINDOW.\n\
524 This is updated by redisplay or by calling `set-window-start'.")
528 return Fmarker_position (decode_window (window
)->start
);
531 /* This is text temporarily removed from the doc string below.
533 This function returns nil if the position is not currently known.\n\
534 That happens when redisplay is preempted and doesn't finish.\n\
535 If in that case you want to compute where the end of the window would\n\
536 have been if redisplay had finished, do this:\n\
538 (goto-char (window-start window))\n\
539 (vertical-motion (1- (window-height window)) window)\n\
542 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
543 "Return position at which display currently ends in WINDOW.\n\
544 This is updated by redisplay, when it runs to completion.\n\
545 Simply changing the buffer text or setting `window-start'\n\
546 does not update this value.")
551 struct window
*w
= decode_window (window
);
555 CHECK_BUFFER (buf
, 0);
557 #if 0 /* This change broke some things. We should make it later. */
558 /* If we don't know the end position, return nil.
559 The user can compute it with vertical-motion if he wants to.
560 It would be nicer to do it automatically,
561 but that's so slow that it would probably bother people. */
562 if (NILP (w
->window_end_valid
))
567 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
572 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
573 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
575 Lisp_Object window
, pos
;
577 register struct window
*w
= decode_window (window
);
579 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
580 if (w
== XWINDOW (selected_window
))
583 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
588 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
589 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
590 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
591 from overriding motion of point in order to display at this exact start.")
592 (window
, pos
, noforce
)
593 Lisp_Object window
, pos
, noforce
;
595 register struct window
*w
= decode_window (window
);
597 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
598 set_marker_restricted (w
->start
, pos
, w
->buffer
);
599 /* this is not right, but much easier than doing what is right. */
600 w
->start_at_line_beg
= Qnil
;
603 w
->update_mode_line
= Qt
;
604 XSETFASTINT (w
->last_modified
, 0);
605 if (!EQ (window
, selected_window
))
606 windows_or_buffers_changed
++;
610 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
612 "Return WINDOW's dedicated object, usually t or nil.\n\
613 See also `set-window-dedicated-p'.")
617 return decode_window (window
)->dedicated
;
620 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
621 Sset_window_dedicated_p
, 2, 2, 0,
622 "Control whether WINDOW is dedicated to the buffer it displays.\n\
623 If it is dedicated, Emacs will not automatically change\n\
624 which buffer appears in it.\n\
625 The second argument is the new value for the dedication flag;\n\
628 Lisp_Object window
, arg
;
630 register struct window
*w
= decode_window (window
);
640 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
642 "Return the display-table that WINDOW is using.")
646 return decode_window (window
)->display_table
;
649 /* Get the display table for use currently on window W.
650 This is either W's display table or W's buffer's display table.
651 Ignore the specified tables if they are not valid;
652 if no valid table is specified, return 0. */
654 struct Lisp_Char_Table
*
655 window_display_table (w
)
659 tem
= w
->display_table
;
660 if (DISP_TABLE_P (tem
))
661 return XCHAR_TABLE (tem
);
662 tem
= XBUFFER (w
->buffer
)->display_table
;
663 if (DISP_TABLE_P (tem
))
664 return XCHAR_TABLE (tem
);
665 tem
= Vstandard_display_table
;
666 if (DISP_TABLE_P (tem
))
667 return XCHAR_TABLE (tem
);
671 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
672 "Set WINDOW's display-table to TABLE.")
674 register Lisp_Object window
, table
;
676 register struct window
*w
;
677 register Lisp_Object z
; /* Return value. */
679 w
= decode_window (window
);
680 w
->display_table
= table
;
684 /* Record info on buffer window w is displaying
685 when it is about to cease to display that buffer. */
688 register struct window
*w
;
693 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
697 if (w
== XWINDOW (selected_window
)
698 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
699 /* Do this except when the selected window's buffer
700 is being removed from some other window. */
702 /* last_window_start records the start position that this buffer
703 had in the last window to be disconnected from it.
704 Now that this statement is unconditional,
705 it is possible for the buffer to be displayed in the
706 selected window, while last_window_start reflects another
707 window which was recently showing the same buffer.
708 Some people might say that might be a good thing. Let's see. */
709 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
711 /* Point in the selected window's buffer
712 is actually stored in that buffer, and the window's pointm isn't used.
713 So don't clobber point in that buffer. */
714 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
715 BUF_PT (XBUFFER (buf
))
716 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
717 marker_position (w
->pointm
),
718 BUF_ZV (XBUFFER (buf
)));
721 /* Put replacement into the window structure in place of old. */
723 replace_window (old
, replacement
)
724 Lisp_Object old
, replacement
;
726 register Lisp_Object tem
;
727 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
729 /* If OLD is its frame's root_window, then replacement is the new
730 root_window for that frame. */
732 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
733 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
738 p
->height
= o
->height
;
740 p
->next
= tem
= o
->next
;
742 XWINDOW (tem
)->prev
= replacement
;
744 p
->prev
= tem
= o
->prev
;
746 XWINDOW (tem
)->next
= replacement
;
748 p
->parent
= tem
= o
->parent
;
751 if (EQ (XWINDOW (tem
)->vchild
, old
))
752 XWINDOW (tem
)->vchild
= replacement
;
753 if (EQ (XWINDOW (tem
)->hchild
, old
))
754 XWINDOW (tem
)->hchild
= replacement
;
757 /*** Here, if replacement is a vertical combination
758 and so is its new parent, we should make replacement's
759 children be children of that parent instead. ***/
762 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
763 "Remove WINDOW from the display. Default is selected window.")
765 register Lisp_Object window
;
767 register Lisp_Object tem
, parent
, sib
;
768 register struct window
*p
;
769 register struct window
*par
;
771 /* Because this function is called by other C code on non-leaf
772 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
773 so we can't decode_window here. */
775 window
= selected_window
;
777 CHECK_WINDOW (window
, 0);
778 p
= XWINDOW (window
);
780 /* It's okay to delete an already-deleted window. */
788 error ("Attempt to delete minibuffer or sole ordinary window");
789 par
= XWINDOW (parent
);
791 windows_or_buffers_changed
++;
792 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (p
))) = 1;
794 /* Are we trying to delete any frame's selected window? */
796 Lisp_Object frame
, pwindow
;
798 /* See if the frame's selected window is either WINDOW
799 or any subwindow of it, by finding all that window's parents
800 and comparing each one with WINDOW. */
801 frame
= WINDOW_FRAME (XWINDOW (window
));
802 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
804 while (!NILP (pwindow
))
806 if (EQ (window
, pwindow
))
808 pwindow
= XWINDOW (pwindow
)->parent
;
811 if (EQ (window
, pwindow
))
813 Lisp_Object alternative
;
814 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
816 /* If we're about to delete the selected window on the
817 selected frame, then we should use Fselect_window to select
818 the new window. On the other hand, if we're about to
819 delete the selected window on any other frame, we shouldn't do
820 anything but set the frame's selected_window slot. */
821 if (EQ (window
, selected_window
))
822 Fselect_window (alternative
);
824 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
829 /* tem is null for dummy parent windows
830 (which have inferiors but not any contents themselves) */
834 unchain_marker (p
->pointm
);
835 unchain_marker (p
->start
);
840 XWINDOW (tem
)->prev
= p
->prev
;
844 XWINDOW (tem
)->next
= p
->next
;
846 if (EQ (window
, par
->hchild
))
847 par
->hchild
= p
->next
;
848 if (EQ (window
, par
->vchild
))
849 par
->vchild
= p
->next
;
851 /* Find one of our siblings to give our space to. */
855 /* If p gives its space to its next sibling, that sibling needs
856 to have its top/left side pulled back to where p's is.
857 set_window_{height,width} will re-position the sibling's
860 XWINDOW (sib
)->top
= p
->top
;
861 XWINDOW (sib
)->left
= p
->left
;
864 /* Stretch that sibling. */
865 if (!NILP (par
->vchild
))
866 set_window_height (sib
,
867 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
869 if (!NILP (par
->hchild
))
870 set_window_width (sib
,
871 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
874 /* If parent now has only one child,
875 put the child into the parent's place. */
879 if (NILP (XWINDOW (tem
)->next
))
880 replace_window (parent
, tem
);
882 /* Since we may be deleting combination windows, we must make sure that
883 not only p but all its children have been marked as deleted. */
884 if (! NILP (p
->hchild
))
885 delete_all_subwindows (XWINDOW (p
->hchild
));
886 else if (! NILP (p
->vchild
))
887 delete_all_subwindows (XWINDOW (p
->vchild
));
889 /* Mark this window as deleted. */
890 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
896 extern Lisp_Object
next_frame (), prev_frame ();
898 /* This comment supplies the doc string for `next-window',
899 for make-docfile to see. We cannot put this in the real DEFUN
900 due to limits in the Unix cpp.
902 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
903 "Return next window after WINDOW in canonical ordering of windows.\n\
904 If omitted, WINDOW defaults to the selected window.\n\
906 Optional second arg MINIBUF t means count the minibuffer window even\n\
907 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
908 it is active. MINIBUF neither t nor nil means not to count the\n\
909 minibuffer even if it is active.\n\
911 Several frames may share a single minibuffer; if the minibuffer\n\
912 counts, all windows on all frames that share that minibuffer count\n\
913 too. Therefore, `next-window' can be used to iterate through the\n\
914 set of windows even when the minibuffer is on another frame. If the\n\
915 minibuffer does not count, only windows from WINDOW's frame count.\n\
917 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
918 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
919 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
920 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
921 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
922 Anything else means restrict to WINDOW's frame.\n\
924 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
925 `next-window' to iterate through the entire cycle of acceptable\n\
926 windows, eventually ending up back at the window you started with.\n\
927 `previous-window' traverses the same cycle, in the reverse order.")
928 (window, minibuf, all_frames) */
930 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
932 (window
, minibuf
, all_frames
)
933 register Lisp_Object window
, minibuf
, all_frames
;
935 register Lisp_Object tem
;
936 Lisp_Object start_window
;
939 window
= selected_window
;
941 CHECK_LIVE_WINDOW (window
, 0);
943 start_window
= window
;
945 /* minibuf == nil may or may not include minibuffers.
946 Decide if it does. */
948 minibuf
= (minibuf_level
? minibuf_window
: Qlambda
);
949 else if (! EQ (minibuf
, Qt
))
951 /* Now minibuf can be t => count all minibuffer windows,
952 lambda => count none of them,
953 or a specific minibuffer window (the active one) to count. */
956 /* all_frames == nil doesn't specify which frames to include. */
957 if (NILP (all_frames
))
958 all_frames
= (! EQ (minibuf
, Qlambda
)
959 ? (FRAME_MINIBUF_WINDOW
962 (XWINDOW (window
)))))
964 else if (EQ (all_frames
, Qvisible
))
966 else if (XFASTINT (all_frames
) == 0)
968 else if (FRAMEP (all_frames
) && ! EQ (all_frames
, Fwindow_frame (window
)))
969 /* If all_frames is a frame and window arg isn't on that frame, just
970 return the first window on the frame. */
971 return Fframe_first_window (all_frames
);
972 else if (! EQ (all_frames
, Qt
))
974 /* Now all_frames is t meaning search all frames,
975 nil meaning search just current frame,
976 visible meaning search just visible frames,
977 0 meaning search visible and iconified frames,
978 or a window, meaning search the frame that window belongs to. */
981 /* Do this loop at least once, to get the next window, and perhaps
982 again, if we hit the minibuffer and that is not acceptable. */
985 /* Find a window that actually has a next one. This loop
986 climbs up the tree. */
987 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
988 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
992 /* We've reached the end of this frame.
993 Which other frames are acceptable? */
994 tem
= WINDOW_FRAME (XWINDOW (window
));
996 if (! NILP (all_frames
))
1001 tem
= next_frame (tem
, all_frames
);
1002 /* In the case where the minibuffer is active,
1003 and we include its frame as well as the selected one,
1004 next_frame may get stuck in that frame.
1005 If that happens, go back to the selected frame
1006 so we can complete the cycle. */
1008 XSETFRAME (tem
, selected_frame
);
1011 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1018 /* If we're in a combination window, find its first child and
1019 recurse on that. Otherwise, we've found the window we want. */
1022 if (!NILP (XWINDOW (window
)->hchild
))
1023 window
= XWINDOW (window
)->hchild
;
1024 else if (!NILP (XWINDOW (window
)->vchild
))
1025 window
= XWINDOW (window
)->vchild
;
1029 /* Which windows are acceptable?
1030 Exit the loop and accept this window if
1031 this isn't a minibuffer window,
1032 or we're accepting all minibuffer windows,
1033 or this is the active minibuffer and we are accepting that one, or
1034 we've come all the way around and we're back at the original window. */
1035 while (MINI_WINDOW_P (XWINDOW (window
))
1036 && ! EQ (minibuf
, Qt
)
1037 && ! EQ (minibuf
, window
)
1038 && ! EQ (window
, start_window
));
1043 /* This comment supplies the doc string for `previous-window',
1044 for make-docfile to see. We cannot put this in the real DEFUN
1045 due to limits in the Unix cpp.
1047 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
1048 "Return the window preceding WINDOW in canonical ordering of windows.\n\
1049 If omitted, WINDOW defaults to the selected window.\n\
1051 Optional second arg MINIBUF t means count the minibuffer window even\n\
1052 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1053 it is active. MINIBUF neither t nor nil means not to count the\n\
1054 minibuffer even if it is active.\n\
1056 Several frames may share a single minibuffer; if the minibuffer\n\
1057 counts, all windows on all frames that share that minibuffer count\n\
1058 too. Therefore, `previous-window' can be used to iterate through\n\
1059 the set of windows even when the minibuffer is on another frame. If\n\
1060 the minibuffer does not count, only windows from WINDOW's frame count\n\
1062 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1063 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1064 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1065 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1066 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
1067 Anything else means restrict to WINDOW's frame.\n\
1069 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1070 `previous-window' to iterate through the entire cycle of acceptable\n\
1071 windows, eventually ending up back at the window you started with.\n\
1072 `next-window' traverses the same cycle, in the reverse order.")
1073 (window, minibuf, all_frames) */
1076 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1078 (window
, minibuf
, all_frames
)
1079 register Lisp_Object window
, minibuf
, all_frames
;
1081 register Lisp_Object tem
;
1082 Lisp_Object start_window
;
1085 window
= selected_window
;
1087 CHECK_LIVE_WINDOW (window
, 0);
1089 start_window
= window
;
1091 /* minibuf == nil may or may not include minibuffers.
1092 Decide if it does. */
1094 minibuf
= (minibuf_level
? minibuf_window
: Qlambda
);
1095 else if (! EQ (minibuf
, Qt
))
1097 /* Now minibuf can be t => count all minibuffer windows,
1098 lambda => count none of them,
1099 or a specific minibuffer window (the active one) to count. */
1102 /* all_frames == nil doesn't specify which frames to include.
1103 Decide which frames it includes. */
1104 if (NILP (all_frames
))
1105 all_frames
= (! EQ (minibuf
, Qlambda
)
1106 ? (FRAME_MINIBUF_WINDOW
1109 (XWINDOW (window
)))))
1111 else if (EQ (all_frames
, Qvisible
))
1113 else if (XFASTINT (all_frames
) == 0)
1115 else if (FRAMEP (all_frames
) && ! EQ (all_frames
, Fwindow_frame (window
)))
1116 /* If all_frames is a frame and window arg isn't on that frame, just
1117 return the first window on the frame. */
1118 return Fframe_first_window (all_frames
);
1119 else if (! EQ (all_frames
, Qt
))
1121 /* Now all_frames is t meaning search all frames,
1122 nil meaning search just current frame,
1123 visible meaning search just visible frames,
1124 0 meaning search visible and iconified frames,
1125 or a window, meaning search the frame that window belongs to. */
1128 /* Do this loop at least once, to get the previous window, and perhaps
1129 again, if we hit the minibuffer and that is not acceptable. */
1132 /* Find a window that actually has a previous one. This loop
1133 climbs up the tree. */
1134 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1135 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1139 /* We have found the top window on the frame.
1140 Which frames are acceptable? */
1141 tem
= WINDOW_FRAME (XWINDOW (window
));
1143 if (! NILP (all_frames
))
1144 /* It's actually important that we use prev_frame here,
1145 rather than next_frame. All the windows acceptable
1146 according to the given parameters should form a ring;
1147 Fnext_window and Fprevious_window should go back and
1148 forth around the ring. If we use next_frame here,
1149 then Fnext_window and Fprevious_window take different
1150 paths through the set of acceptable windows.
1151 window_loop assumes that these `ring' requirement are
1157 tem
= prev_frame (tem
, all_frames
);
1158 /* In the case where the minibuffer is active,
1159 and we include its frame as well as the selected one,
1160 next_frame may get stuck in that frame.
1161 If that happens, go back to the selected frame
1162 so we can complete the cycle. */
1164 XSETFRAME (tem
, selected_frame
);
1167 /* If this frame has a minibuffer, find that window first,
1168 because it is conceptually the last window in that frame. */
1169 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1170 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1172 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1178 /* If we're in a combination window, find its last child and
1179 recurse on that. Otherwise, we've found the window we want. */
1182 if (!NILP (XWINDOW (window
)->hchild
))
1183 window
= XWINDOW (window
)->hchild
;
1184 else if (!NILP (XWINDOW (window
)->vchild
))
1185 window
= XWINDOW (window
)->vchild
;
1187 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1191 /* Which windows are acceptable?
1192 Exit the loop and accept this window if
1193 this isn't a minibuffer window,
1194 or we're accepting all minibuffer windows,
1195 or this is the active minibuffer and we are accepting that one, or
1196 we've come all the way around and we're back at the original window. */
1197 while (MINI_WINDOW_P (XWINDOW (window
))
1198 && ! EQ (minibuf
, Qt
)
1199 && ! EQ (minibuf
, window
)
1200 && ! EQ (window
, start_window
));
1205 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1206 "Select the ARG'th different window on this frame.\n\
1207 All windows on current frame are arranged in a cyclic order.\n\
1208 This command selects the window ARG steps away in that order.\n\
1209 A negative ARG moves in the opposite order. If the optional second\n\
1210 argument ALL_FRAMES is non-nil, cycle through all frames.")
1212 register Lisp_Object arg
, all_frames
;
1215 register Lisp_Object w
;
1217 CHECK_NUMBER (arg
, 0);
1218 w
= selected_window
;
1223 w
= Fnext_window (w
, Qnil
, all_frames
);
1228 w
= Fprevious_window (w
, Qnil
, all_frames
);
1235 /* Look at all windows, performing an operation specified by TYPE
1237 If FRAMES is Qt, look at all frames;
1238 Qnil, look at just the selected frame;
1239 Qvisible, look at visible frames;
1240 a frame, just look at windows on that frame.
1241 If MINI is non-zero, perform the operation on minibuffer windows too.
1247 GET_BUFFER_WINDOW
, /* Arg is buffer */
1248 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1249 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1250 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1252 UNSHOW_BUFFER
/* Arg is buffer */
1256 window_loop (type
, obj
, mini
, frames
)
1257 enum window_loop type
;
1258 register Lisp_Object obj
, frames
;
1261 register Lisp_Object w
;
1262 register Lisp_Object best_window
;
1263 register Lisp_Object next_window
;
1264 register Lisp_Object last_window
;
1266 Lisp_Object frame_arg
;
1270 /* If we're only looping through windows on a particular frame,
1271 frame points to that frame. If we're looping through windows
1272 on all frames, frame is 0. */
1273 if (FRAMEP (frames
))
1274 frame
= XFRAME (frames
);
1275 else if (NILP (frames
))
1276 frame
= selected_frame
;
1280 frame_arg
= Qlambda
;
1281 else if (XFASTINT (frames
) == 0)
1283 else if (EQ (frames
, Qvisible
))
1289 /* frame_arg is Qlambda to stick to one frame,
1290 Qvisible to consider all visible frames,
1293 /* Pick a window to start with. */
1297 w
= FRAME_SELECTED_WINDOW (frame
);
1299 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1301 /* Figure out the last window we're going to mess with. Since
1302 Fnext_window, given the same options, is guaranteed to go in a
1303 ring, we can just use Fprevious_window to find the last one.
1305 We can't just wait until we hit the first window again, because
1306 it might be deleted. */
1308 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1313 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1315 /* Pick the next window now, since some operations will delete
1316 the current window. */
1317 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1319 /* Note that we do not pay attention here to whether
1320 the frame is visible, since Fnext_window skips non-visible frames
1321 if that is desired, under the control of frame_arg. */
1322 if (! MINI_WINDOW_P (XWINDOW (w
))
1323 || (mini
&& minibuf_level
> 0))
1326 case GET_BUFFER_WINDOW
:
1327 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1331 case GET_LRU_WINDOW
:
1332 /* t as arg means consider only full-width windows */
1333 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1334 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1336 /* Ignore dedicated windows and minibuffers. */
1337 if (MINI_WINDOW_P (XWINDOW (w
))
1338 || !NILP (XWINDOW (w
)->dedicated
))
1340 if (NILP (best_window
)
1341 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1342 > XFASTINT (XWINDOW (w
)->use_time
)))
1346 case DELETE_OTHER_WINDOWS
:
1347 if (XWINDOW (w
) != XWINDOW (obj
))
1351 case DELETE_BUFFER_WINDOWS
:
1352 if (EQ (XWINDOW (w
)->buffer
, obj
))
1355 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1357 /* If this window is dedicated, and in a frame of its own,
1359 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1360 && !NILP (XWINDOW (w
)->dedicated
)
1361 && other_visible_frames (f
))
1363 /* Skip the other windows on this frame.
1364 There might be one, the minibuffer! */
1365 if (! EQ (w
, last_window
))
1366 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1368 /* As we go, check for the end of the loop.
1369 We mustn't start going around a second time. */
1370 if (EQ (next_window
, last_window
))
1375 next_window
= Fnext_window (next_window
,
1379 /* Now we can safely delete the frame. */
1380 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1384 /* If we're deleting the buffer displayed in the only window
1385 on the frame, find a new buffer to display there. */
1386 if (NILP (XWINDOW (w
)->parent
))
1388 Lisp_Object new_buffer
;
1389 new_buffer
= Fother_buffer (obj
, Qnil
);
1390 if (NILP (new_buffer
))
1392 = Fget_buffer_create (build_string ("*scratch*"));
1393 Fset_window_buffer (w
, new_buffer
);
1394 if (EQ (w
, selected_window
))
1395 Fset_buffer (XWINDOW (w
)->buffer
);
1402 case GET_LARGEST_WINDOW
:
1403 /* Ignore dedicated windows and minibuffers. */
1404 if (MINI_WINDOW_P (XWINDOW (w
))
1405 || !NILP (XWINDOW (w
)->dedicated
))
1408 struct window
*best_window_ptr
= XWINDOW (best_window
);
1409 struct window
*w_ptr
= XWINDOW (w
);
1410 if (NILP (best_window
)
1411 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1412 > (XFASTINT (best_window_ptr
->height
)
1413 * XFASTINT (best_window_ptr
->width
))))
1419 if (EQ (XWINDOW (w
)->buffer
, obj
))
1421 /* Find another buffer to show in this window. */
1422 Lisp_Object another_buffer
;
1423 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1424 another_buffer
= Fother_buffer (obj
, Qnil
);
1425 if (NILP (another_buffer
))
1427 = Fget_buffer_create (build_string ("*scratch*"));
1429 /* If this window is dedicated, and in a frame of its own,
1431 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1432 && !NILP (XWINDOW (w
)->dedicated
)
1433 && other_visible_frames (f
))
1435 /* Skip the other windows on this frame.
1436 There might be one, the minibuffer! */
1437 if (! EQ (w
, last_window
))
1438 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1440 /* As we go, check for the end of the loop.
1441 We mustn't start going around a second time. */
1442 if (EQ (next_window
, last_window
))
1447 next_window
= Fnext_window (next_window
,
1451 /* Now we can safely delete the frame. */
1452 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1457 /* Otherwise show a different buffer in the window. */
1458 XWINDOW (w
)->dedicated
= Qnil
;
1459 Fset_window_buffer (w
, another_buffer
);
1460 if (EQ (w
, selected_window
))
1461 Fset_buffer (XWINDOW (w
)->buffer
);
1467 if (EQ (w
, last_window
))
1476 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1477 "Return the window least recently selected or used for display.\n\
1478 If optional argument FRAME is `visible', search all visible frames.\n\
1479 If FRAME is 0, search all visible and iconified frames.\n\
1480 If FRAME is t, search all frames.\n\
1481 If FRAME is nil, search only the selected frame.\n\
1482 If FRAME is a frame, search only that frame.")
1486 register Lisp_Object w
;
1487 /* First try for a window that is full-width */
1488 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1489 if (!NILP (w
) && !EQ (w
, selected_window
))
1491 /* If none of them, try the rest */
1492 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1495 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1496 "Return the largest window in area.\n\
1497 If optional argument FRAME is `visible', search all visible frames.\n\
1498 If FRAME is 0, search all visible and iconified frames.\n\
1499 If FRAME is t, search all frames.\n\
1500 If FRAME is nil, search only the selected frame.\n\
1501 If FRAME is a frame, search only that frame.")
1505 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1509 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1510 "Return a window currently displaying BUFFER, or nil if none.\n\
1511 If optional argument FRAME is `visible', search all visible frames.\n\
1512 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1513 If FRAME is t, search all frames.\n\
1514 If FRAME is nil, search only the selected frame.\n\
1515 If FRAME is a frame, search only that frame.")
1517 Lisp_Object buffer
, frame
;
1519 buffer
= Fget_buffer (buffer
);
1520 if (BUFFERP (buffer
))
1521 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1526 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1528 "Make WINDOW (or the selected window) fill its frame.\n\
1529 Only the frame WINDOW is on is affected.\n\
1530 This function tries to reduce display jumps\n\
1531 by keeping the text previously visible in WINDOW\n\
1532 in the same place on the frame. Doing this depends on\n\
1533 the value of (window-start WINDOW), so if calling this function\n\
1534 in a program gives strange scrolling, make sure the window-start\n\
1535 value is reasonable when this function is called.")
1544 window
= selected_window
;
1546 CHECK_LIVE_WINDOW (window
, 0);
1548 w
= XWINDOW (window
);
1550 startpos
= marker_position (w
->start
);
1551 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1553 if (MINI_WINDOW_P (w
) && top
> 0)
1554 error ("Can't expand minibuffer to full frame");
1556 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1558 /* Try to minimize scrolling, by setting the window start to the point
1559 will cause the text at the old window start to be at the same place
1560 on the frame. But don't try to do this if the window start is
1561 outside the visible portion (as might happen when the display is
1562 not current, due to typeahead). */
1563 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1564 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1566 struct position pos
;
1567 struct buffer
*obuf
= current_buffer
;
1569 Fset_buffer (w
->buffer
);
1570 /* This computation used to temporarily move point, but that can
1571 have unwanted side effects due to text properties. */
1572 pos
= *vmotion (startpos
, -top
, w
);
1573 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1574 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1575 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1577 /* We need to do this, so that the window-scroll-functions
1579 w
->force_start
= Qt
;
1581 set_buffer_internal (obuf
);
1586 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1587 1, 2, "bDelete windows on (buffer): ",
1588 "Delete all windows showing BUFFER.\n\
1589 Optional second argument FRAME controls which frames are affected.\n\
1590 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1591 If t, delete only windows showing BUFFER in the selected frame.\n\
1592 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1593 If a frame, delete only windows showing BUFFER in that frame.")
1595 Lisp_Object buffer
, frame
;
1598 /* FRAME uses t and nil to mean the opposite of what window_loop
1600 if (! FRAMEP (frame
))
1601 frame
= NILP (frame
) ? Qt
: Qnil
;
1608 buffer
= Fget_buffer (buffer
);
1609 CHECK_BUFFER (buffer
, 0);
1610 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1615 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1616 Sreplace_buffer_in_windows
,
1617 1, 1, "bReplace buffer in windows: ",
1618 "Replace BUFFER with some other buffer in all windows showing it.")
1624 buffer
= Fget_buffer (buffer
);
1625 CHECK_BUFFER (buffer
, 0);
1626 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1631 /* Replace BUFFER with some other buffer in all windows
1632 of all frames, even those on other keyboards. */
1635 replace_buffer_in_all_windows (buffer
)
1639 Lisp_Object tail
, frame
;
1641 /* A single call to window_loop won't do the job
1642 because it only considers frames on the current keyboard.
1643 So loop manually over frames, and handle each one. */
1644 FOR_EACH_FRAME (tail
, frame
)
1645 window_loop (UNSHOW_BUFFER
, buffer
, 0, frame
);
1647 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1651 /* Set the height of WINDOW and all its inferiors. */
1653 /* The smallest acceptable dimensions for a window. Anything smaller
1654 might crash Emacs. */
1655 #define MIN_SAFE_WINDOW_WIDTH (2)
1656 #define MIN_SAFE_WINDOW_HEIGHT (2)
1658 /* Make sure that window_min_height and window_min_width are
1659 not too small; if they are, set them to safe minima. */
1662 check_min_window_sizes ()
1664 /* Smaller values might permit a crash. */
1665 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1666 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1667 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1668 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1671 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1672 minimum allowable size. */
1674 check_frame_size (frame
, rows
, cols
)
1678 /* For height, we have to see:
1679 whether the frame has a minibuffer,
1680 whether it wants a mode line, and
1681 whether it has a menu bar. */
1683 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1684 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1685 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1686 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1687 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1689 if (*rows
< min_height
)
1691 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1692 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1695 /* Normally the window is deleted if it gets too small.
1696 nodelete nonzero means do not do this.
1697 (The caller should check later and do so if appropriate) */
1699 set_window_height (window
, height
, nodelete
)
1704 register struct window
*w
= XWINDOW (window
);
1705 register struct window
*c
;
1706 int oheight
= XFASTINT (w
->height
);
1707 int top
, pos
, lastbot
, opos
, lastobot
;
1710 check_min_window_sizes ();
1713 && ! NILP (w
->parent
)
1714 && height
< window_min_height
)
1716 Fdelete_window (window
);
1720 XSETFASTINT (w
->last_modified
, 0);
1721 windows_or_buffers_changed
++;
1722 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1724 XSETFASTINT (w
->height
, height
);
1725 if (!NILP (w
->hchild
))
1727 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1729 XWINDOW (child
)->top
= w
->top
;
1730 set_window_height (child
, height
, nodelete
);
1733 else if (!NILP (w
->vchild
))
1735 lastbot
= top
= XFASTINT (w
->top
);
1737 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1739 c
= XWINDOW (child
);
1741 opos
= lastobot
+ XFASTINT (c
->height
);
1743 XSETFASTINT (c
->top
, lastbot
);
1745 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1747 /* Avoid confusion: inhibit deletion of child if becomes too small */
1748 set_window_height (child
, pos
+ top
- lastbot
, 1);
1750 /* Now advance child to next window,
1751 and set lastbot if child was not just deleted. */
1752 lastbot
= pos
+ top
;
1755 /* Now delete any children that became too small. */
1757 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1759 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1764 /* Recursively set width of WINDOW and its inferiors. */
1766 set_window_width (window
, width
, nodelete
)
1771 register struct window
*w
= XWINDOW (window
);
1772 register struct window
*c
;
1773 int owidth
= XFASTINT (w
->width
);
1774 int left
, pos
, lastright
, opos
, lastoright
;
1777 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1779 Fdelete_window (window
);
1783 XSETFASTINT (w
->last_modified
, 0);
1784 windows_or_buffers_changed
++;
1785 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1787 XSETFASTINT (w
->width
, width
);
1788 if (!NILP (w
->vchild
))
1790 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1792 XWINDOW (child
)->left
= w
->left
;
1793 set_window_width (child
, width
, nodelete
);
1796 else if (!NILP (w
->hchild
))
1798 lastright
= left
= XFASTINT (w
->left
);
1800 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1802 c
= XWINDOW (child
);
1804 opos
= lastoright
+ XFASTINT (c
->width
);
1806 XSETFASTINT (c
->left
, lastright
);
1808 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1810 /* Inhibit deletion for becoming too small */
1811 set_window_width (child
, pos
+ left
- lastright
, 1);
1813 /* Now advance child to next window,
1814 and set lastright if child was not just deleted. */
1815 lastright
= pos
+ left
, lastoright
= opos
;
1817 /* Delete children that became too small */
1819 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1821 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1826 int window_select_count
;
1828 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1829 "Make WINDOW display BUFFER as its contents.\n\
1830 BUFFER can be a buffer or buffer name.")
1832 register Lisp_Object window
, buffer
;
1834 register Lisp_Object tem
;
1835 register struct window
*w
= decode_window (window
);
1837 buffer
= Fget_buffer (buffer
);
1838 CHECK_BUFFER (buffer
, 1);
1840 if (NILP (XBUFFER (buffer
)->name
))
1841 error ("Attempt to display deleted buffer");
1845 error ("Window is deleted");
1846 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1847 is first being set up. */
1849 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1850 error ("Window is dedicated to `%s'",
1851 XSTRING (XBUFFER (tem
)->name
)->data
);
1857 XSETFASTINT (w
->window_end_pos
, 0);
1858 w
->window_end_valid
= Qnil
;
1859 XSETFASTINT (w
->hscroll
, 0);
1860 Fset_marker (w
->pointm
,
1861 make_number (BUF_PT (XBUFFER (buffer
))),
1863 set_marker_restricted (w
->start
,
1864 make_number (XBUFFER (buffer
)->last_window_start
),
1866 w
->start_at_line_beg
= Qnil
;
1867 w
->force_start
= Qnil
;
1868 XSETFASTINT (w
->last_modified
, 0);
1869 windows_or_buffers_changed
++;
1870 if (EQ (window
, selected_window
))
1871 Fset_buffer (buffer
);
1872 if (! NILP (Vwindow_scroll_functions
))
1873 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1874 Fmarker_position (w
->start
));
1879 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1880 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1881 The main editor command loop selects the buffer of the selected window\n\
1882 before each command.")
1884 register Lisp_Object window
;
1886 register struct window
*w
;
1887 register struct window
*ow
= XWINDOW (selected_window
);
1889 CHECK_LIVE_WINDOW (window
, 0);
1891 w
= XWINDOW (window
);
1893 if (NILP (w
->buffer
))
1894 error ("Trying to select deleted window or non-leaf window");
1896 XSETFASTINT (w
->use_time
, ++window_select_count
);
1897 if (EQ (window
, selected_window
))
1900 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1903 selected_window
= window
;
1905 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1907 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1908 /* Use this rather than Fhandle_switch_frame
1909 so that FRAME_FOCUS_FRAME is moved appropriately as we
1910 move around in the state where a minibuffer in a separate
1912 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1915 selected_frame
->selected_window
= window
;
1918 record_buffer (w
->buffer
);
1919 Fset_buffer (w
->buffer
);
1921 /* Go to the point recorded in the window.
1922 This is important when the buffer is in more
1923 than one window. It also matters when
1924 redisplay_window has altered point after scrolling,
1925 because it makes the change only in the window. */
1927 register int new_point
= marker_position (w
->pointm
);
1928 if (new_point
< BEGV
)
1930 else if (new_point
> ZV
)
1936 windows_or_buffers_changed
++;
1940 /* Deiconify the frame containing the window WINDOW,
1941 unless it is the selected frame;
1944 The reason for the exception for the selected frame
1945 is that it seems better not to change the selected frames visibility
1946 merely because of displaying a different buffer in it.
1947 The deiconification is useful when a buffer gets shown in
1948 another frame that you were not using lately. */
1951 display_buffer_1 (window
)
1955 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1956 FRAME_SAMPLE_VISIBILITY (f
);
1957 if (FRAME_ICONIFIED_P (f
)
1958 && f
!= selected_frame
)
1959 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1964 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1965 "bDisplay buffer: \nP",
1966 "Make BUFFER appear in some window but don't select it.\n\
1967 BUFFER can be a buffer or a buffer name.\n\
1968 If BUFFER is shown already in some window, just use that one,\n\
1969 unless the window is the selected window and the optional second\n\
1970 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1971 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1972 Returns the window displaying BUFFER.")
1973 (buffer
, not_this_window
)
1974 register Lisp_Object buffer
, not_this_window
;
1976 register Lisp_Object window
, tem
;
1978 buffer
= Fget_buffer (buffer
);
1979 CHECK_BUFFER (buffer
, 0);
1981 if (!NILP (Vdisplay_buffer_function
))
1982 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1984 if (NILP (not_this_window
)
1985 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1986 return display_buffer_1 (selected_window
);
1988 /* See if the user has specified this buffer should appear
1989 in the selected window. */
1990 if (NILP (not_this_window
))
1992 tem
= Fmember (XBUFFER (buffer
)->name
, Vsame_window_buffer_names
);
1995 Fswitch_to_buffer (buffer
, Qnil
);
1996 return display_buffer_1 (selected_window
);
1999 tem
= Fassoc (XBUFFER (buffer
)->name
, Vsame_window_buffer_names
);
2002 Fswitch_to_buffer (buffer
, Qnil
);
2003 return display_buffer_1 (selected_window
);
2006 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
2008 Lisp_Object car
= XCONS (tem
)->car
;
2010 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
2012 Fswitch_to_buffer (buffer
, Qnil
);
2013 return display_buffer_1 (selected_window
);
2015 else if (CONSP (car
)
2016 && STRINGP (XCONS (car
)->car
)
2017 && fast_string_match (XCONS (car
)->car
,
2018 XBUFFER (buffer
)->name
) >= 0)
2020 Fswitch_to_buffer (buffer
, Qnil
);
2021 return display_buffer_1 (selected_window
);
2027 /* If pop_up_frames,
2028 look for a window showing BUFFER on any visible or iconified frame.
2029 Otherwise search only the current frame. */
2030 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
2031 XSETFASTINT (tem
, 0);
2034 XSETFRAME (tem
, last_nonminibuf_frame
);
2035 window
= Fget_buffer_window (buffer
, tem
);
2037 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
2039 return display_buffer_1 (window
);
2042 /* Certain buffer names get special handling. */
2043 if (! NILP (Vspecial_display_function
))
2045 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
2047 return call1 (Vspecial_display_function
, buffer
);
2049 tem
= Fassoc (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
2051 return call2 (Vspecial_display_function
, buffer
, XCONS (tem
)->cdr
);
2053 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
2055 Lisp_Object car
= XCONS (tem
)->car
;
2057 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
2058 return call1 (Vspecial_display_function
, buffer
);
2059 else if (CONSP (car
)
2060 && STRINGP (XCONS (car
)->car
)
2061 && fast_string_match (XCONS (car
)->car
,
2062 XBUFFER (buffer
)->name
) >= 0)
2063 return call2 (Vspecial_display_function
,
2070 /* If there are no frames open that have more than a minibuffer,
2071 we need to create a new frame. */
2072 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
2074 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2075 Fset_window_buffer (window
, buffer
);
2076 return display_buffer_1 (window
);
2078 #endif /* MULTI_FRAME */
2082 || FRAME_MINIBUF_ONLY_P (selected_frame
)
2083 /* If the current frame is a special display frame,
2084 don't try to reuse its windows. */
2085 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
2093 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
2094 XSETFRAME (frames
, last_nonminibuf_frame
);
2096 /* Don't try to create a window if would get an error */
2097 if (split_height_threshold
< window_min_height
<< 1)
2098 split_height_threshold
= window_min_height
<< 1;
2100 /* Note that both Fget_largest_window and Fget_lru_window
2101 ignore minibuffers and dedicated windows.
2102 This means they can return nil. */
2105 /* If the frame we would try to split cannot be split,
2106 try other frames. */
2107 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
2108 : last_nonminibuf_frame
))
2110 /* Try visible frames first. */
2111 window
= Fget_largest_window (Qvisible
);
2112 /* If that didn't work, try iconified frames. */
2114 window
= Fget_largest_window (make_number (0));
2116 window
= Fget_largest_window (Qt
);
2120 window
= Fget_largest_window (frames
);
2122 /* If we got a tall enough full-width window that can be split,
2125 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2126 && window_height (window
) >= split_height_threshold
2127 && (XFASTINT (XWINDOW (window
)->width
)
2128 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
2129 window
= Fsplit_window (window
, Qnil
, Qnil
);
2132 Lisp_Object upper
, lower
, other
;
2134 window
= Fget_lru_window (frames
);
2135 /* If the LRU window is selected, and big enough,
2136 and can be split, split it. */
2138 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2139 && (EQ (window
, selected_window
)
2140 || EQ (XWINDOW (window
)->parent
, Qnil
))
2141 && window_height (window
) >= window_min_height
<< 1)
2142 window
= Fsplit_window (window
, Qnil
, Qnil
);
2144 /* If Fget_lru_window returned nil, try other approaches. */
2145 /* Try visible frames first. */
2147 window
= Fget_largest_window (Qvisible
);
2148 /* If that didn't work, try iconified frames. */
2150 window
= Fget_largest_window (make_number (0));
2151 /* Try invisible frames. */
2153 window
= Fget_largest_window (Qt
);
2154 /* As a last resort, make a new frame. */
2156 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2158 /* As a last resort, use a non minibuffer window. */
2160 window
= Fframe_first_window (Fselected_frame ());
2162 /* If window appears above or below another,
2163 even out their heights. */
2164 other
= upper
= lower
= Qnil
;
2165 if (!NILP (XWINDOW (window
)->prev
))
2166 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
2167 if (!NILP (XWINDOW (window
)->next
))
2168 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
2170 /* Check that OTHER and WINDOW are vertically arrayed. */
2171 && XWINDOW (other
)->top
!= XWINDOW (window
)->top
2172 && XWINDOW (other
)->height
> XWINDOW (window
)->height
)
2174 int total
= XWINDOW (other
)->height
+ XWINDOW (window
)->height
;
2175 Lisp_Object old_selected_window
;
2176 old_selected_window
= selected_window
;
2178 selected_window
= upper
;
2179 change_window_height (total
/ 2 - XWINDOW (upper
)->height
, 0);
2180 selected_window
= old_selected_window
;
2185 window
= Fget_lru_window (Qnil
);
2187 Fset_window_buffer (window
, buffer
);
2188 return display_buffer_1 (window
);
2192 temp_output_buffer_show (buf
)
2193 register Lisp_Object buf
;
2195 register struct buffer
*old
= current_buffer
;
2196 register Lisp_Object window
;
2197 register struct window
*w
;
2200 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
2204 XBUFFER (buf
)->clip_changed
= 1;
2205 set_buffer_internal (old
);
2207 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
2208 call1 (Vtemp_buffer_show_function
, buf
);
2211 window
= Fdisplay_buffer (buf
, Qnil
);
2214 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2215 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2216 #endif /* MULTI_FRAME */
2217 Vminibuf_scroll_window
= window
;
2218 w
= XWINDOW (window
);
2219 XSETFASTINT (w
->hscroll
, 0);
2220 set_marker_restricted (w
->start
, make_number (1), buf
);
2221 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2223 /* Run temp-buffer-show-hook, with the chosen window selected. */
2224 if (!NILP (Vrun_hooks
))
2227 tem
= Fboundp (Qtemp_buffer_show_hook
);
2230 tem
= Fsymbol_value (Qtemp_buffer_show_hook
);
2233 int count
= specpdl_ptr
- specpdl
;
2235 /* Select the window that was chosen, for running the hook. */
2236 record_unwind_protect (Fset_window_configuration
,
2237 Fcurrent_window_configuration (Qnil
));
2239 Fselect_window (window
);
2240 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
2241 unbind_to (count
, Qnil
);
2249 make_dummy_parent (window
)
2253 register struct window
*o
, *p
;
2254 register struct Lisp_Vector
*vec
;
2257 o
= XWINDOW (window
);
2258 vec
= allocate_vectorlike ((EMACS_INT
)VECSIZE (struct window
));
2259 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
2260 vec
->contents
[i
] = ((struct Lisp_Vector
*)o
)->contents
[i
];
2261 vec
->size
= VECSIZE (struct window
);
2262 p
= (struct window
*)vec
;
2263 XSETWINDOW (new, p
);
2265 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
2267 /* Put new into window structure in place of window */
2268 replace_window (window
, new);
2281 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2282 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2283 WINDOW defaults to selected one and SIZE to half its size.\n\
2284 If optional third arg HORFLAG is non-nil, split side by side\n\
2285 and put SIZE columns in the first of the pair.")
2286 (window
, size
, horflag
)
2287 Lisp_Object window
, size
, horflag
;
2289 register Lisp_Object
new;
2290 register struct window
*o
, *p
;
2292 register int size_int
;
2294 int separator_width
= 1;
2297 window
= selected_window
;
2299 CHECK_LIVE_WINDOW (window
, 0);
2301 o
= XWINDOW (window
);
2302 fo
= XFRAME (WINDOW_FRAME (o
));
2303 if (FRAME_HAS_VERTICAL_SCROLL_BARS (fo
))
2304 separator_width
= FRAME_SCROLL_BAR_COLS (fo
);
2305 internal_width
= window_internal_width (o
);
2309 if (!NILP (horflag
))
2310 /* Calculate the size of the left-hand window, by dividing
2311 the usable space in columns by two. */
2312 size_int
= (internal_width
- separator_width
) >> 1;
2314 size_int
= XFASTINT (o
->height
) >> 1;
2318 CHECK_NUMBER (size
, 1);
2319 size_int
= XINT (size
);
2322 if (MINI_WINDOW_P (o
))
2323 error ("Attempt to split minibuffer window");
2324 else if (FRAME_NO_SPLIT_P (fo
))
2325 error ("Attempt to split unsplittable frame");
2327 check_min_window_sizes ();
2331 if (size_int
< window_min_height
)
2332 error ("Window height %d too small (after splitting)", size_int
);
2333 if (size_int
+ window_min_height
> XFASTINT (o
->height
))
2334 error ("Window height %d too small (after splitting)",
2335 XFASTINT (o
->height
) - size_int
);
2336 if (NILP (o
->parent
)
2337 || NILP (XWINDOW (o
->parent
)->vchild
))
2339 make_dummy_parent (window
);
2341 XWINDOW (new)->vchild
= window
;
2346 if (size_int
< window_min_width
)
2347 error ("Window width %d too small (after splitting)", size_int
);
2348 if (internal_width
- size_int
- separator_width
< window_min_width
)
2349 error ("Window width %d too small (after splitting)",
2350 internal_width
- size_int
- separator_width
);
2351 if (NILP (o
->parent
)
2352 || NILP (XWINDOW (o
->parent
)->hchild
))
2354 make_dummy_parent (window
);
2356 XWINDOW (new)->hchild
= window
;
2360 /* Now we know that window's parent is a vertical combination
2361 if we are dividing vertically, or a horizontal combination
2362 if we are making side-by-side windows */
2364 windows_or_buffers_changed
++;
2365 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
2366 new = make_window ();
2369 p
->frame
= o
->frame
;
2371 if (!NILP (p
->next
))
2372 XWINDOW (p
->next
)->prev
= new;
2375 p
->parent
= o
->parent
;
2378 Fset_window_buffer (new, o
->buffer
);
2380 /* Apportion the available frame space among the two new windows */
2382 if (!NILP (horflag
))
2384 p
->height
= o
->height
;
2386 size_int
+= separator_width
;
2387 XSETFASTINT (p
->width
, internal_width
- size_int
);
2388 XSETFASTINT (o
->width
, size_int
);
2389 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size_int
);
2394 p
->width
= o
->width
;
2395 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size_int
);
2396 XSETFASTINT (o
->height
, size_int
);
2397 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size_int
);
2403 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2404 "Make current window ARG lines bigger.\n\
2405 From program, optional second arg non-nil means grow sideways ARG columns.")
2407 register Lisp_Object arg
, side
;
2409 CHECK_NUMBER (arg
, 0);
2410 change_window_height (XINT (arg
), !NILP (side
));
2414 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2415 "Make current window ARG lines smaller.\n\
2416 From program, optional second arg non-nil means shrink sideways arg columns.")
2418 register Lisp_Object arg
, side
;
2420 CHECK_NUMBER (arg
, 0);
2421 change_window_height (-XINT (arg
), !NILP (side
));
2426 window_height (window
)
2429 register struct window
*p
= XWINDOW (window
);
2430 return XFASTINT (p
->height
);
2434 window_width (window
)
2437 register struct window
*p
= XWINDOW (window
);
2438 return XFASTINT (p
->width
);
2441 #define MINSIZE(w) \
2443 ? window_min_width \
2444 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2447 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2449 #define CURSIZE(w) \
2450 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2452 /* Unlike set_window_height, this function
2453 also changes the heights of the siblings so as to
2454 keep everything consistent. */
2456 change_window_height (delta
, widthflag
)
2460 register Lisp_Object parent
;
2462 register struct window
*p
;
2464 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2465 register int (*setsizefun
) () = (widthflag
2467 : set_window_height
);
2469 check_min_window_sizes ();
2471 window
= selected_window
;
2474 p
= XWINDOW (window
);
2479 error ("No other window to side of this one");
2482 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2483 : !NILP (XWINDOW (parent
)->vchild
))
2488 sizep
= &CURSIZE (window
);
2491 register int maxdelta
;
2493 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2494 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2495 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2496 /* This is a frame with only one window, a minibuffer-only
2497 or a minibufferless frame. */
2500 if (delta
> maxdelta
)
2501 /* This case traps trying to make the minibuffer
2502 the full frame, or make the only window aside from the
2503 minibuffer the full frame. */
2507 if (*sizep
+ delta
< MINSIZE (window
))
2509 Fdelete_window (window
);
2517 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2519 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2520 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2521 CURBEG (p
->next
) += delta
;
2522 /* This does not change size of p->next,
2523 but it propagates the new top edge to its children */
2524 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2526 else if (!NILP (p
->prev
)
2527 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2529 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2530 CURBEG (window
) -= delta
;
2531 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2535 register int delta1
;
2536 register int opht
= (*sizefun
) (parent
);
2538 /* If trying to grow this window to or beyond size of the parent,
2539 make delta1 so big that, on shrinking back down,
2540 all the siblings end up with less than one line and are deleted. */
2541 if (opht
<= *sizep
+ delta
)
2542 delta1
= opht
* opht
* 2;
2543 /* Otherwise, make delta1 just right so that if we add delta1
2544 lines to this window and to the parent, and then shrink
2545 the parent back to its original size, the new proportional
2546 size of this window will increase by delta. */
2548 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2550 /* Add delta1 lines or columns to this window, and to the parent,
2551 keeping things consistent while not affecting siblings. */
2552 CURSIZE (parent
) = opht
+ delta1
;
2553 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2555 /* Squeeze out delta1 lines or columns from our parent,
2556 shriking this window and siblings proportionately.
2557 This brings parent back to correct size.
2558 Delta1 was calculated so this makes this window the desired size,
2559 taking it all out of the siblings. */
2560 (*setsizefun
) (parent
, opht
, 0);
2563 XSETFASTINT (p
->last_modified
, 0);
2570 /* Return number of lines of text (not counting mode line) in W. */
2573 window_internal_height (w
)
2576 int ht
= XFASTINT (w
->height
);
2578 if (MINI_WINDOW_P (w
))
2581 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2582 || !NILP (w
->next
) || !NILP (w
->prev
)
2583 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2590 /* Return the number of columns in W.
2591 Don't count columns occupied by scroll bars or the vertical bar
2592 separating W from the sibling to its right. */
2594 window_internal_width (w
)
2597 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2598 int left
= XINT (w
->left
);
2599 int width
= XINT (w
->width
);
2601 /* If this window is flush against the right edge of the frame, its
2602 internal width is its full width. */
2603 if (left
+ width
>= FRAME_WIDTH (f
))
2606 /* If we are not flush right, then our rightmost columns are
2607 occupied by some sort of separator. */
2609 /* Scroll bars occupy a few columns. */
2610 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2611 return width
- FRAME_SCROLL_BAR_COLS (f
);
2613 /* The column of `|' characters separating side-by-side windows
2614 occupies one column only. */
2619 /* Scroll contents of window WINDOW up N lines. */
2622 window_scroll (window
, n
, noerror
)
2627 register struct window
*w
= XWINDOW (window
);
2628 register int opoint
= PT
;
2630 register int ht
= window_internal_height (w
);
2631 register Lisp_Object tem
;
2633 Lisp_Object bolp
, nmoved
;
2635 /* Always set force_start so that redisplay_window will run
2636 the window-scroll-functions. */
2637 w
->force_start
= Qt
;
2639 XSETFASTINT (tem
, PT
);
2640 tem
= Fpos_visible_in_window_p (tem
, window
);
2644 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2645 XSETFASTINT (tem
, PT
);
2646 Fset_marker (w
->start
, tem
, w
->buffer
);
2649 SET_PT (marker_position (w
->start
));
2650 lose
= n
< 0 && PT
== BEGV
;
2651 Fvertical_motion (make_number (n
), window
);
2661 Fsignal (Qbeginning_of_buffer
, Qnil
);
2666 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2667 w
->start_at_line_beg
= bolp
;
2668 w
->update_mode_line
= Qt
;
2669 XSETFASTINT (w
->last_modified
, 0);
2675 tem
= Fvertical_motion (make_number (ht
), window
);
2676 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2679 Fvertical_motion (make_number (-1), window
);
2687 Fsignal (Qend_of_buffer
, Qnil
);
2691 /* This is the guts of Fscroll_up and Fscroll_down. */
2694 scroll_command (n
, direction
)
2695 register Lisp_Object n
;
2698 register int defalt
;
2699 int count
= specpdl_ptr
- specpdl
;
2701 /* If selected window's buffer isn't current, make it current for the moment.
2702 But don't screw up if window_scroll gets an error. */
2703 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2705 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2706 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2709 defalt
= (window_internal_height (XWINDOW (selected_window
))
2710 - next_screen_context_lines
);
2711 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2714 window_scroll (selected_window
, defalt
, 0);
2715 else if (EQ (n
, Qminus
))
2716 window_scroll (selected_window
, - defalt
, 0);
2719 n
= Fprefix_numeric_value (n
);
2720 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2723 unbind_to (count
, Qnil
);
2726 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2727 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2728 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2729 Negative ARG means scroll downward.\n\
2730 When calling from a program, supply a number as argument or nil.")
2734 scroll_command (arg
, 1);
2738 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2739 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2740 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2741 Negative ARG means scroll upward.\n\
2742 When calling from a program, supply a number as argument or nil.")
2746 scroll_command (arg
, -1);
2750 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2751 "Return the other window for \"other window scroll\" commands.\n\
2752 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2753 specifies the window.\n\
2754 If `other-window-scroll-buffer' is non-nil, a window\n\
2755 showing that buffer is used.")
2760 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2761 && !NILP (Vminibuf_scroll_window
))
2762 window
= Vminibuf_scroll_window
;
2763 /* If buffer is specified, scroll that buffer. */
2764 else if (!NILP (Vother_window_scroll_buffer
))
2766 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2768 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2772 /* Nothing specified; look for a neighboring window on the same
2774 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2776 if (EQ (window
, selected_window
))
2777 /* That didn't get us anywhere; look for a window on another
2780 window
= Fnext_window (window
, Qnil
, Qt
);
2781 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2782 && ! EQ (window
, selected_window
));
2785 CHECK_LIVE_WINDOW (window
, 0);
2787 if (EQ (window
, selected_window
))
2788 error ("There is no other window");
2793 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2794 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2795 The next window is the one below the current one; or the one at the top\n\
2796 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2797 When calling from a program, supply a number as argument or nil.\n\
2799 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2800 specifies the window to scroll.\n\
2801 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2802 showing that buffer, popping the buffer up if necessary.")
2804 register Lisp_Object arg
;
2806 register Lisp_Object window
;
2807 register int defalt
;
2808 register struct window
*w
;
2809 register int count
= specpdl_ptr
- specpdl
;
2811 window
= Fother_window_for_scrolling ();
2813 w
= XWINDOW (window
);
2814 defalt
= window_internal_height (w
) - next_screen_context_lines
;
2815 if (defalt
< 1) defalt
= 1;
2817 /* Don't screw up if window_scroll gets an error. */
2818 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2820 Fset_buffer (w
->buffer
);
2821 SET_PT (marker_position (w
->pointm
));
2824 window_scroll (window
, defalt
, 1);
2825 else if (EQ (arg
, Qminus
))
2826 window_scroll (window
, -defalt
, 1);
2831 CHECK_NUMBER (arg
, 0);
2832 window_scroll (window
, XINT (arg
), 1);
2835 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2836 unbind_to (count
, Qnil
);
2841 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2842 "Scroll selected window display ARG columns left.\n\
2843 Default for ARG is window width minus 2.")
2845 register Lisp_Object arg
;
2849 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2851 arg
= Fprefix_numeric_value (arg
);
2854 Fset_window_hscroll (selected_window
,
2855 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2859 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2860 "Scroll selected window display ARG columns right.\n\
2861 Default for ARG is window width minus 2.")
2863 register Lisp_Object arg
;
2866 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2868 arg
= Fprefix_numeric_value (arg
);
2871 Fset_window_hscroll (selected_window
,
2872 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2876 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2877 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2878 The desired position of point is always relative to the current window.\n\
2879 Just C-u as prefix means put point in the center of the window.\n\
2880 If ARG is omitted or nil, erases the entire frame and then\n\
2881 redraws with point in the center of the current window.")
2883 register Lisp_Object arg
;
2885 register struct window
*w
= XWINDOW (selected_window
);
2886 register int ht
= window_internal_height (w
);
2887 struct position pos
;
2891 extern int frame_garbaged
;
2893 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2894 XSETFASTINT (arg
, ht
/ 2);
2896 else if (CONSP (arg
)) /* Just C-u. */
2898 XSETFASTINT (arg
, ht
/ 2);
2902 arg
= Fprefix_numeric_value (arg
);
2903 CHECK_NUMBER (arg
, 0);
2907 XSETINT (arg
, XINT (arg
) + ht
);
2909 pos
= *vmotion (point
, - XINT (arg
), w
);
2911 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
2912 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
2913 || FETCH_CHAR (pos
.bufpos
- 1) == '\n')
2915 w
->force_start
= Qt
;
2920 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2922 "Position point relative to window.\n\
2923 With no argument, position point at center of window.\n\
2924 An argument specifies frame line; zero means top of window,\n\
2925 negative means relative to bottom of window.")
2927 register Lisp_Object arg
;
2929 register struct window
*w
= XWINDOW (selected_window
);
2930 register int height
= window_internal_height (w
);
2935 XSETFASTINT (arg
, height
/ 2);
2938 arg
= Fprefix_numeric_value (arg
);
2940 XSETINT (arg
, XINT (arg
) + height
);
2943 start
= marker_position (w
->start
);
2944 XSETWINDOW (window
, w
);
2945 if (start
< BEGV
|| start
> ZV
)
2947 Fvertical_motion (make_number (- (height
/ 2)), window
);
2948 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2949 w
->start_at_line_beg
= Fbolp ();
2950 w
->force_start
= Qt
;
2955 return Fvertical_motion (arg
, window
);
2958 struct save_window_data
2960 int size_from_Lisp_Vector_struct
;
2961 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2962 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2963 Lisp_Object selected_frame
;
2964 Lisp_Object current_window
;
2965 Lisp_Object current_buffer
;
2966 Lisp_Object minibuf_scroll_window
;
2967 Lisp_Object root_window
;
2968 Lisp_Object focus_frame
;
2969 /* Record the values of window-min-width and window-min-height
2970 so that window sizes remain consistent with them. */
2971 Lisp_Object min_width
, min_height
;
2972 /* A vector, interpreted as a struct saved_window */
2973 Lisp_Object saved_windows
;
2976 /* This is saved as a Lisp_Vector */
2979 /* these first two must agree with struct Lisp_Vector in lisp.h */
2980 int size_from_Lisp_Vector_struct
;
2981 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2984 Lisp_Object buffer
, start
, pointm
, mark
;
2985 Lisp_Object left
, top
, width
, height
, hscroll
;
2986 Lisp_Object parent
, prev
;
2987 Lisp_Object start_at_line_beg
;
2988 Lisp_Object display_table
;
2990 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2992 #define SAVED_WINDOW_N(swv,n) \
2993 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2995 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2996 "T if OBJECT is a window-configuration object.")
3000 if (WINDOW_CONFIGURATIONP (object
))
3006 DEFUN ("set-window-configuration", Fset_window_configuration
,
3007 Sset_window_configuration
, 1, 1, 0,
3008 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
3009 CONFIGURATION must be a value previously returned\n\
3010 by `current-window-configuration' (which see).")
3012 Lisp_Object configuration
;
3014 register struct save_window_data
*data
;
3015 struct Lisp_Vector
*saved_windows
;
3016 Lisp_Object new_current_buffer
;
3020 while (!WINDOW_CONFIGURATIONP (configuration
))
3022 configuration
= wrong_type_argument (intern ("window-configuration-p"),
3026 data
= (struct save_window_data
*) XVECTOR (configuration
);
3027 saved_windows
= XVECTOR (data
->saved_windows
);
3029 new_current_buffer
= data
->current_buffer
;
3030 if (NILP (XBUFFER (new_current_buffer
)->name
))
3031 new_current_buffer
= Qnil
;
3033 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
3036 /* If f is a dead frame, don't bother rebuilding its window tree.
3037 However, there is other stuff we should still try to do below. */
3038 if (FRAME_LIVE_P (f
))
3040 register struct window
*w
;
3041 register struct saved_window
*p
;
3044 /* If the frame has been resized since this window configuration was
3045 made, we change the frame to the size specified in the
3046 configuration, restore the configuration, and then resize it
3047 back. We keep track of the prevailing height in these variables. */
3048 int previous_frame_height
= FRAME_HEIGHT (f
);
3049 int previous_frame_width
= FRAME_WIDTH (f
);
3050 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
3052 if (XFASTINT (data
->frame_height
) != previous_frame_height
3053 || XFASTINT (data
->frame_width
) != previous_frame_width
)
3054 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
3055 #ifdef HAVE_WINDOW_SYSTEM
3056 if (XFASTINT (data
->frame_menu_bar_lines
)
3057 != previous_frame_menu_bar_lines
)
3058 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
3061 windows_or_buffers_changed
++;
3062 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3064 /* Temporarily avoid any problems with windows that are smaller
3065 than they are supposed to be. */
3066 window_min_height
= 1;
3067 window_min_width
= 1;
3070 Mark all windows now on frame as "deleted".
3071 Restoring the new configuration "undeletes" any that are in it.
3073 Save their current buffers in their height fields, since we may
3074 need it later, if a buffer saved in the configuration is now
3076 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3078 for (k
= 0; k
< saved_windows
->size
; k
++)
3080 p
= SAVED_WINDOW_N (saved_windows
, k
);
3081 w
= XWINDOW (p
->window
);
3084 if (!NILP (p
->parent
))
3085 w
->parent
= SAVED_WINDOW_N (saved_windows
,
3086 XFASTINT (p
->parent
))->window
;
3090 if (!NILP (p
->prev
))
3092 w
->prev
= SAVED_WINDOW_N (saved_windows
,
3093 XFASTINT (p
->prev
))->window
;
3094 XWINDOW (w
->prev
)->next
= p
->window
;
3099 if (!NILP (w
->parent
))
3101 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
3103 XWINDOW (w
->parent
)->vchild
= p
->window
;
3104 XWINDOW (w
->parent
)->hchild
= Qnil
;
3108 XWINDOW (w
->parent
)->hchild
= p
->window
;
3109 XWINDOW (w
->parent
)->vchild
= Qnil
;
3114 /* If we squirreled away the buffer in the window's height,
3116 if (BUFFERP (w
->height
))
3117 w
->buffer
= w
->height
;
3120 w
->width
= p
->width
;
3121 w
->height
= p
->height
;
3122 w
->hscroll
= p
->hscroll
;
3123 w
->display_table
= p
->display_table
;
3124 XSETFASTINT (w
->last_modified
, 0);
3126 /* Reinstall the saved buffer and pointers into it. */
3127 if (NILP (p
->buffer
))
3128 w
->buffer
= p
->buffer
;
3131 if (!NILP (XBUFFER (p
->buffer
)->name
))
3132 /* If saved buffer is alive, install it. */
3134 w
->buffer
= p
->buffer
;
3135 w
->start_at_line_beg
= p
->start_at_line_beg
;
3136 set_marker_restricted (w
->start
,
3137 Fmarker_position (p
->start
),
3139 set_marker_restricted (w
->pointm
,
3140 Fmarker_position (p
->pointm
),
3142 Fset_marker (XBUFFER (w
->buffer
)->mark
,
3143 Fmarker_position (p
->mark
), w
->buffer
);
3145 /* As documented in Fcurrent_window_configuration, don't
3146 save the location of point in the buffer which was current
3147 when the window configuration was recorded. */
3148 if (!EQ (p
->buffer
, new_current_buffer
)
3149 && XBUFFER (p
->buffer
) == current_buffer
)
3150 Fgoto_char (w
->pointm
);
3152 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
3153 /* Else unless window has a live buffer, get one. */
3155 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
3156 /* This will set the markers to beginning of visible
3158 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
3159 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
3160 w
->start_at_line_beg
= Qt
;
3163 /* Keeping window's old buffer; make sure the markers
3166 /* Set window markers at start of visible range. */
3167 if (XMARKER (w
->start
)->buffer
== 0)
3168 set_marker_restricted (w
->start
, make_number (0),
3170 if (XMARKER (w
->pointm
)->buffer
== 0)
3171 set_marker_restricted (w
->pointm
,
3173 (BUF_PT (XBUFFER (w
->buffer
)))),
3175 w
->start_at_line_beg
= Qt
;
3180 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
3181 Fselect_window (data
->current_window
);
3184 if (NILP (data
->focus_frame
)
3185 || (FRAMEP (data
->focus_frame
)
3186 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
3187 Fredirect_frame_focus (frame
, data
->focus_frame
);
3190 #if 0 /* I don't understand why this is needed, and it causes problems
3191 when the frame's old selected window has been deleted. */
3193 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
3194 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
3199 /* Set the screen height to the value it had before this function. */
3200 if (previous_frame_height
!= FRAME_HEIGHT (f
)
3201 || previous_frame_width
!= FRAME_WIDTH (f
))
3202 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
3204 #ifdef HAVE_WINDOW_SYSTEM
3205 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
3206 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
3210 /* Restore the minimum heights recorded in the configuration. */
3211 window_min_height
= XINT (data
->min_height
);
3212 window_min_width
= XINT (data
->min_width
);
3215 /* Fselect_window will have made f the selected frame, so we
3216 reselect the proper frame here. Fhandle_switch_frame will change the
3217 selected window too, but that doesn't make the call to
3218 Fselect_window above totally superfluous; it still sets f's
3220 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
3221 do_switch_frame (data
->selected_frame
, Qnil
, 0);
3224 if (!NILP (new_current_buffer
))
3225 Fset_buffer (new_current_buffer
);
3227 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
3231 /* Mark all windows now on frame as deleted
3232 by setting their buffers to nil. */
3235 delete_all_subwindows (w
)
3236 register struct window
*w
;
3238 if (!NILP (w
->next
))
3239 delete_all_subwindows (XWINDOW (w
->next
));
3240 if (!NILP (w
->vchild
))
3241 delete_all_subwindows (XWINDOW (w
->vchild
));
3242 if (!NILP (w
->hchild
))
3243 delete_all_subwindows (XWINDOW (w
->hchild
));
3245 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3247 /* We set all three of these fields to nil, to make sure that we can
3248 distinguish this dead window from any live window. Live leaf
3249 windows will have buffer set, and combination windows will have
3250 vchild or hchild set. */
3257 count_windows (window
)
3258 register struct window
*window
;
3260 register int count
= 1;
3261 if (!NILP (window
->next
))
3262 count
+= count_windows (XWINDOW (window
->next
));
3263 if (!NILP (window
->vchild
))
3264 count
+= count_windows (XWINDOW (window
->vchild
));
3265 if (!NILP (window
->hchild
))
3266 count
+= count_windows (XWINDOW (window
->hchild
));
3271 save_window_save (window
, vector
, i
)
3273 struct Lisp_Vector
*vector
;
3276 register struct saved_window
*p
;
3277 register struct window
*w
;
3278 register Lisp_Object tem
;
3280 for (;!NILP (window
); window
= w
->next
)
3282 p
= SAVED_WINDOW_N (vector
, i
);
3283 w
= XWINDOW (window
);
3285 XSETFASTINT (w
->temslot
, i
++);
3287 p
->buffer
= w
->buffer
;
3290 p
->width
= w
->width
;
3291 p
->height
= w
->height
;
3292 p
->hscroll
= w
->hscroll
;
3293 p
->display_table
= w
->display_table
;
3294 if (!NILP (w
->buffer
))
3296 /* Save w's value of point in the window configuration.
3297 If w is the selected window, then get the value of point
3298 from the buffer; pointm is garbage in the selected window. */
3299 if (EQ (window
, selected_window
))
3301 p
->pointm
= Fmake_marker ();
3302 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
3306 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
3308 p
->start
= Fcopy_marker (w
->start
, Qnil
);
3309 p
->start_at_line_beg
= w
->start_at_line_beg
;
3311 tem
= XBUFFER (w
->buffer
)->mark
;
3312 p
->mark
= Fcopy_marker (tem
, Qnil
);
3319 p
->start_at_line_beg
= Qnil
;
3322 if (NILP (w
->parent
))
3325 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3330 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3332 if (!NILP (w
->vchild
))
3333 i
= save_window_save (w
->vchild
, vector
, i
);
3334 if (!NILP (w
->hchild
))
3335 i
= save_window_save (w
->hchild
, vector
, i
);
3341 DEFUN ("current-window-configuration",
3342 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3343 "Return an object representing the current window configuration of FRAME.\n\
3344 If FRAME is nil or omitted, use the selected frame.\n\
3345 This describes the number of windows, their sizes and current buffers,\n\
3346 and for each displayed buffer, where display starts, and the positions of\n\
3347 point and mark. An exception is made for point in the current buffer:\n\
3348 its value is -not- saved.\n\
3349 This also records the currently selected frame, and FRAME's focus\n\
3350 redirection (see `redirect-frame-focus').")
3354 register Lisp_Object tem
;
3355 register int n_windows
;
3356 register struct save_window_data
*data
;
3357 register struct Lisp_Vector
*vec
;
3365 CHECK_LIVE_FRAME (frame
, 0);
3369 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3370 vec
= allocate_vectorlike (VECSIZE (struct save_window_data
));
3371 for (i
= 0; i
< VECSIZE (struct save_window_data
); i
++)
3372 vec
->contents
[i
] = Qnil
;
3373 vec
->size
= VECSIZE (struct save_window_data
);
3374 data
= (struct save_window_data
*)vec
;
3376 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
3377 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
3378 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
3380 XSETFRAME (data
->selected_frame
, selected_frame
);
3382 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3383 XSETBUFFER (data
->current_buffer
, current_buffer
);
3384 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3385 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3386 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3387 XSETINT (data
->min_height
, window_min_height
);
3388 XSETINT (data
->min_width
, window_min_width
);
3389 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3390 data
->saved_windows
= tem
;
3391 for (i
= 0; i
< n_windows
; i
++)
3392 XVECTOR (tem
)->contents
[i
]
3393 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3394 save_window_save (FRAME_ROOT_WINDOW (f
),
3396 XSETWINDOW_CONFIGURATION (tem
, data
);
3400 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3402 "Execute body, preserving window sizes and contents.\n\
3403 Restore which buffer appears in which window, where display starts,\n\
3404 and the value of point and mark for each window.\n\
3405 Also restore which buffer is current.\n\
3406 But do not preserve point in the current buffer.\n\
3407 Does not restore the value of point in current buffer.")
3411 register Lisp_Object val
;
3412 register int count
= specpdl_ptr
- specpdl
;
3414 record_unwind_protect (Fset_window_configuration
,
3415 Fcurrent_window_configuration (Qnil
));
3416 val
= Fprogn (args
);
3417 return unbind_to (count
, val
);
3423 selected_frame
= make_terminal_frame ();
3424 XSETFRAME (Vterminal_frame
, selected_frame
);
3425 minibuf_window
= selected_frame
->minibuffer_window
;
3426 selected_window
= selected_frame
->selected_window
;
3427 last_nonminibuf_frame
= selected_frame
;
3428 #else /* not MULTI_FRAME */
3429 extern Lisp_Object
get_minibuffer ();
3431 selected_frame
= last_nonminibuf_frame
= &the_only_frame
;
3433 minibuf_window
= make_window ();
3434 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3436 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3437 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3438 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3440 /* These values 9 and 10 are arbitrary,
3441 just so that there is "something there."
3442 Correct values are put in in init_xdisp */
3444 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
, 10);
3445 XSETFASTINT (XWINDOW (minibuf_window
)->width
, 10);
3447 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
, 9);
3448 XSETFASTINT (XWINDOW (minibuf_window
)->top
, 9);
3449 XSETFASTINT (XWINDOW (minibuf_window
)->height
, 1);
3451 /* Prevent error in Fset_window_buffer. */
3452 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3453 XWINDOW (minibuf_window
)->buffer
= Qt
;
3455 /* Now set them up for real. */
3456 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3457 Fcurrent_buffer ());
3458 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3460 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3461 /* Make sure this window seems more recently used than
3462 a newly-created, never-selected window. Increment
3463 window_select_count so the first selection ever will get
3464 something newer than this. */
3465 XSETFASTINT (XWINDOW (selected_window
)->use_time
, ++window_select_count
);
3466 #endif /* not MULTI_FRAME */
3471 Qwindowp
= intern ("windowp");
3472 staticpro (&Qwindowp
);
3474 Qwindow_live_p
= intern ("window-live-p");
3475 staticpro (&Qwindow_live_p
);
3477 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
3478 staticpro (&Qtemp_buffer_show_hook
);
3481 /* Make sure all windows get marked */
3482 staticpro (&minibuf_window
);
3485 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3486 "Non-nil means call as function to display a help buffer.\n\
3487 The function is called with one argument, the buffer to be displayed.\n\
3488 Used by `with-output-to-temp-buffer'.\n\
3489 If this function is used, then it must do the entire job of showing\n\
3490 the buffer; `temp-buffer-show-hook' is not run unless this function runs it.");
3491 Vtemp_buffer_show_function
= Qnil
;
3493 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3494 "If non-nil, function to call to handle `display-buffer'.\n\
3495 It will receive two args, the buffer and a flag which if non-nil means\n\
3496 that the currently selected window is not acceptable.\n\
3497 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3498 work using this function.");
3499 Vdisplay_buffer_function
= Qnil
;
3501 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3502 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3503 Vminibuf_scroll_window
= Qnil
;
3505 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3506 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3507 Vother_window_scroll_buffer
= Qnil
;
3509 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3510 "*Non-nil means `display-buffer' should make a separate frame.");
3513 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3514 "Function to call to handle automatic new frame creation.\n\
3515 It is called with no arguments and should return a newly created frame.\n\
3517 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3518 where `pop-up-frame-alist' would hold the default frame parameters.");
3519 Vpop_up_frame_function
= Qnil
;
3521 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3522 "*List of buffer names that should have their own special frames.\n\
3523 Displaying a buffer whose name is in this list makes a special frame for it\n\
3524 using `special-display-function'.\n\
3526 An element of the list can be a cons cell instead of just a string.\n\
3527 Then the car should be a buffer name, and the cdr specifies frame\n\
3528 parameters for creating the frame for that buffer.\n\
3529 More precisely, the cdr is passed as the second argument to\n\
3530 the function found in `special-display-function', when making that frame.\n\
3531 See also `special-display-regexps'.");
3532 Vspecial_display_buffer_names
= Qnil
;
3534 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3535 "*List of regexps saying which buffers should have their own special frames.\n\
3536 If a buffer name matches one of these regexps, it gets its own frame.\n\
3537 Displaying a buffer whose name is in this list makes a special frame for it\n\
3538 using `special-display-function'.\n\
3540 An element of the list can be a cons cell instead of just a string.\n\
3541 Then the car should be the regexp, and the cdr specifies frame\n\
3542 parameters for creating the frame for buffers that match.\n\
3543 More precisely, the cdr is passed as the second argument to\n\
3544 the function found in `special-display-function', when making that frame.\n\
3545 See also `special-display-buffer-names'.");
3546 Vspecial_display_regexps
= Qnil
;
3548 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3549 "Function to call to make a new frame for a special buffer.\n\
3550 It is called with two arguments, the buffer and optional buffer specific\n\
3551 data, and should return a window displaying that buffer.\n\
3552 The default value makes a separate frame for the buffer,\n\
3553 using `special-display-frame-alist' to specify the frame parameters.\n\
3555 A buffer is special if its is listed in `special-display-buffer-names'\n\
3556 or matches a regexp in `special-display-regexps'.");
3557 Vspecial_display_function
= Qnil
;
3559 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
3560 "*List of buffer names that should appear in the selected window.\n\
3561 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
3562 switches to it in the selected window, rather than making it appear\n\
3563 in some other window.\n\
3565 An element of the list can be a cons cell instead of just a string.\n\
3566 Then the car must be a string, which specifies the buffer name.\n\
3567 This is for compatibility with `special-display-buffer-names';\n\
3568 the cdr of the cons cell is ignored.\n\
3570 See also `same-window-regexps'.");
3571 Vsame_window_buffer_names
= Qnil
;
3573 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
3574 "*List of regexps saying which buffers should appear in the selected window.\n\
3575 If a buffer name matches one of these regexps, then displaying it\n\
3576 using `display-buffer' or `pop-to-buffer' switches to it\n\
3577 in the selected window, rather than making it appear in some other window.\n\
3579 An element of the list can be a cons cell instead of just a string.\n\
3580 Then the car must be a string, which specifies the buffer name.\n\
3581 This is for compatibility with `special-display-buffer-names';\n\
3582 the cdr of the cons cell is ignored.\n\
3584 See also `same-window-buffer-names'.");
3585 Vsame_window_regexps
= Qnil
;
3587 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3588 "*Non-nil means display-buffer should make new windows.");
3591 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3592 "*Number of lines of continuity when scrolling by screenfuls.");
3593 next_screen_context_lines
= 2;
3595 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3596 "*display-buffer would prefer to split the largest window if this large.\n\
3597 If there is only one window, it is split regardless of this value.");
3598 split_height_threshold
= 500;
3600 DEFVAR_INT ("window-min-height", &window_min_height
,
3601 "*Delete any window less than this tall (including its mode line).");
3602 window_min_height
= 4;
3604 DEFVAR_INT ("window-min-width", &window_min_width
,
3605 "*Delete any window less than this wide.");
3606 window_min_width
= 10;
3608 defsubr (&Sselected_window
);
3609 defsubr (&Sminibuffer_window
);
3610 defsubr (&Swindow_minibuffer_p
);
3611 defsubr (&Swindowp
);
3612 defsubr (&Swindow_live_p
);
3613 defsubr (&Spos_visible_in_window_p
);
3614 defsubr (&Swindow_buffer
);
3615 defsubr (&Swindow_height
);
3616 defsubr (&Swindow_width
);
3617 defsubr (&Swindow_hscroll
);
3618 defsubr (&Sset_window_hscroll
);
3619 defsubr (&Swindow_redisplay_end_trigger
);
3620 defsubr (&Sset_window_redisplay_end_trigger
);
3621 defsubr (&Swindow_edges
);
3622 defsubr (&Scoordinates_in_window_p
);
3623 defsubr (&Swindow_at
);
3624 defsubr (&Swindow_point
);
3625 defsubr (&Swindow_start
);
3626 defsubr (&Swindow_end
);
3627 defsubr (&Sset_window_point
);
3628 defsubr (&Sset_window_start
);
3629 defsubr (&Swindow_dedicated_p
);
3630 defsubr (&Sset_window_dedicated_p
);
3631 defsubr (&Swindow_display_table
);
3632 defsubr (&Sset_window_display_table
);
3633 defsubr (&Snext_window
);
3634 defsubr (&Sprevious_window
);
3635 defsubr (&Sother_window
);
3636 defsubr (&Sget_lru_window
);
3637 defsubr (&Sget_largest_window
);
3638 defsubr (&Sget_buffer_window
);
3639 defsubr (&Sdelete_other_windows
);
3640 defsubr (&Sdelete_windows_on
);
3641 defsubr (&Sreplace_buffer_in_windows
);
3642 defsubr (&Sdelete_window
);
3643 defsubr (&Sset_window_buffer
);
3644 defsubr (&Sselect_window
);
3645 defsubr (&Sdisplay_buffer
);
3646 defsubr (&Ssplit_window
);
3647 defsubr (&Senlarge_window
);
3648 defsubr (&Sshrink_window
);
3649 defsubr (&Sscroll_up
);
3650 defsubr (&Sscroll_down
);
3651 defsubr (&Sscroll_left
);
3652 defsubr (&Sscroll_right
);
3653 defsubr (&Sother_window_for_scrolling
);
3654 defsubr (&Sscroll_other_window
);
3655 defsubr (&Srecenter
);
3656 defsubr (&Smove_to_window_line
);
3657 defsubr (&Swindow_configuration_p
);
3658 defsubr (&Sset_window_configuration
);
3659 defsubr (&Scurrent_window_configuration
);
3660 defsubr (&Ssave_window_excursion
);
3665 initial_define_key (control_x_map
, '1', "delete-other-windows");
3666 initial_define_key (control_x_map
, '2', "split-window");
3667 initial_define_key (control_x_map
, '0', "delete-window");
3668 initial_define_key (control_x_map
, 'o', "other-window");
3669 initial_define_key (control_x_map
, '^', "enlarge-window");
3670 initial_define_key (control_x_map
, '<', "scroll-left");
3671 initial_define_key (control_x_map
, '>', "scroll-right");
3673 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3674 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3675 initial_define_key (meta_map
, 'v', "scroll-down");
3677 initial_define_key (global_map
, Ctl('L'), "recenter");
3678 initial_define_key (meta_map
, 'r', "move-to-window-line");