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, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 Lisp_Object Qwindowp
, Qwindow_live_p
;
34 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
35 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
37 void delete_all_subwindows ();
38 static struct window
*decode_window();
40 /* This is the window in which the terminal's cursor should
41 be left when nothing is being done with it. This must
42 always be a leaf window, and its buffer is selected by
43 the top level editing loop at the end of each command.
45 This value is always the same as
46 FRAME_SELECTED_WINDOW (selected_frame). */
48 Lisp_Object selected_window
;
50 /* The minibuffer window of the selected frame.
51 Note that you cannot test for minibufferness of an arbitrary window
52 by comparing against this; but you can test for minibufferness of
53 the selected window. */
54 Lisp_Object minibuf_window
;
56 /* Non-nil means it is the window for C-M-v to scroll
57 when the minibuffer is selected. */
58 Lisp_Object Vminibuf_scroll_window
;
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
61 Lisp_Object Vother_window_scroll_buffer
;
63 /* Non-nil means it's function to call to display temp buffers. */
64 Lisp_Object Vtemp_buffer_show_function
;
66 /* If a window gets smaller than either of these, it is removed. */
67 int window_min_height
;
70 /* Nonzero implies Fdisplay_buffer should create windows. */
73 /* Nonzero implies make new frames for Fdisplay_buffer. */
76 /* Non-nil means use this function instead of default */
77 Lisp_Object Vpop_up_frame_function
;
79 /* Function to call to handle Fdisplay_buffer. */
80 Lisp_Object Vdisplay_buffer_function
;
82 /* List of buffer *names* for buffers that should have their own frames. */
83 Lisp_Object Vspecial_display_buffer_names
;
85 /* List of regexps for buffer names that should have their own frames. */
86 Lisp_Object Vspecial_display_regexps
;
88 /* Function to pop up a special frame. */
89 Lisp_Object Vspecial_display_function
;
91 /* List of buffer *names* for buffers to appear in selected window. */
92 Lisp_Object Vsame_window_buffer_names
;
94 /* List of regexps for buffer names to appear in selected window. */
95 Lisp_Object Vsame_window_regexps
;
97 /* Hook run at end of temp_output_buffer_show. */
98 Lisp_Object Qtemp_buffer_show_hook
;
100 /* Fdisplay_buffer always splits the largest window
101 if that window is more than this high. */
102 int split_height_threshold
;
104 /* Number of lines of continuity in scrolling by screenfuls. */
105 int next_screen_context_lines
;
107 /* Incremented for each window created. */
108 static int sequence_number
;
110 #define min(a, b) ((a) < (b) ? (a) : (b))
112 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
113 "Returns t if OBJ is a window.")
117 return WINDOWP (obj
) ? Qt
: Qnil
;
120 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
121 "Returns t if OBJ is a window which is currently visible.")
125 return (WINDOWP (obj
) && ! NILP (XWINDOW (obj
)->buffer
) ? Qt
: Qnil
);
132 register struct window
*p
;
133 register struct Lisp_Vector
*vec
;
136 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct window
));
137 for (i
= 0; i
< VECSIZE (struct window
); i
++)
138 vec
->contents
[i
] = Qnil
;
139 vec
->size
= VECSIZE (struct window
);
140 p
= (struct window
*)vec
;
141 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
142 XSETFASTINT (p
->left
, 0);
143 XSETFASTINT (p
->top
, 0);
144 XSETFASTINT (p
->height
, 0);
145 XSETFASTINT (p
->width
, 0);
146 XSETFASTINT (p
->hscroll
, 0);
147 XSETFASTINT (p
->last_point_x
, 0);
148 XSETFASTINT (p
->last_point_y
, 0);
149 p
->start
= Fmake_marker ();
150 p
->pointm
= Fmake_marker ();
151 XSETFASTINT (p
->use_time
, 0);
153 p
->display_table
= Qnil
;
159 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
160 "Return the window that the cursor now appears in and commands apply to.")
163 return selected_window
;
166 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
167 "Return the window used now for minibuffers.\n\
168 If the optional argument FRAME is specified, return the minibuffer window\n\
169 used by that frame.")
175 XSETFRAME (frame
, selected_frame
);
177 CHECK_LIVE_FRAME (frame
, 0);
180 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
183 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
184 "Returns non-nil if WINDOW is a minibuffer window.")
188 struct window
*w
= decode_window (window
);
189 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
192 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
193 Spos_visible_in_window_p
, 0, 2, 0,
194 "Return t if position POS is currently on the frame in WINDOW.\n\
195 Returns nil if that position is scrolled vertically out of view.\n\
196 POS defaults to point; WINDOW, to the selected window.")
198 Lisp_Object pos
, window
;
200 register struct window
*w
;
204 register struct buffer
*buf
;
205 struct position posval
;
212 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
216 w
= decode_window (window
);
217 top
= marker_position (w
->start
);
218 hscroll
= XINT (w
->hscroll
);
223 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
225 buf
= XBUFFER (w
->buffer
);
226 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
228 /* If frame is up to date,
229 use the info recorded about how much text fit on it. */
230 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
231 || (XFASTINT (w
->window_end_vpos
) < height
))
237 if (posint
> BUF_ZV (buf
))
240 /* w->start can be out of range. If it is, do something reasonable. */
241 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
244 /* If that info is not correct, calculate afresh */
245 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
247 window_internal_width (w
) - 1,
250 return posval
.vpos
< height
? Qt
: Qnil
;
254 static struct window
*
255 decode_window (window
)
256 register Lisp_Object window
;
259 return XWINDOW (selected_window
);
261 CHECK_LIVE_WINDOW (window
, 0);
262 return XWINDOW (window
);
265 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
266 "Return the buffer that WINDOW is displaying.")
270 return decode_window (window
)->buffer
;
273 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
274 "Return the number of lines in WINDOW (including its mode line).")
278 return decode_window (window
)->height
;
281 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
282 "Return the number of display columns in WINDOW.\n\
283 This is the width that is usable columns available for text in WINDOW.\n\
284 If you want to find out how many columns WINDOW takes up,\n\
285 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
289 return make_number (window_internal_width (decode_window (window
)));
292 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
293 "Return the number of columns by which WINDOW is scrolled from left margin.")
297 return decode_window (window
)->hscroll
;
300 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
301 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
302 NCOL should be zero or positive.")
304 register Lisp_Object window
, ncol
;
306 register struct window
*w
;
308 CHECK_NUMBER (ncol
, 1);
309 if (XINT (ncol
) < 0) XSETFASTINT (ncol
, 0);
310 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
311 args_out_of_range (ncol
, Qnil
);
312 w
= decode_window (window
);
313 if (XINT (w
->hscroll
) != XINT (ncol
))
314 clip_changed
= 1; /* Prevent redisplay shortcuts */
319 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
320 "Return a list of the edge coordinates of WINDOW.\n\
321 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
322 RIGHT is one more than the rightmost column used by WINDOW,\n\
323 and BOTTOM is one more than the bottommost row used by WINDOW\n\
328 register struct window
*w
= decode_window (window
);
330 return Fcons (w
->left
, Fcons (w
->top
,
331 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
332 Fcons (make_number (XFASTINT (w
->top
)
333 + XFASTINT (w
->height
)),
337 /* Test if the character at column *x, row *y is within window *w.
338 If it is not, return 0;
339 if it is in the window's text area,
340 set *x and *y to its location relative to the upper left corner
343 if it is on the window's modeline, return 2;
344 if it is on the border between the window and its right sibling,
347 coordinates_in_window (w
, x
, y
)
348 register struct window
*w
;
351 register int left
= XINT (w
->left
);
352 register int width
= XINT (w
->width
);
353 register int window_height
= XINT (w
->height
);
354 register int top
= XFASTINT (w
->top
);
356 if ( *x
< left
|| *x
>= left
+ width
357 || *y
< top
|| *y
>= top
+ window_height
)
360 /* Is the character is the mode line? */
361 if (*y
== top
+ window_height
- 1
362 && ! MINI_WINDOW_P (w
))
365 /* Is the character in the right border? */
366 if (*x
== left
+ width
- 1
367 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
375 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
376 Scoordinates_in_window_p
, 2, 2, 0,
377 "Return non-nil if COORDINATES are in WINDOW.\n\
378 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
379 measured in characters from the upper-left corner of the frame.\n\
380 (0 . 0) denotes the character in the upper left corner of the\n\
382 If COORDINATES are in the text portion of WINDOW,\n\
383 the coordinates relative to the window are returned.\n\
384 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
385 If they are on the border between WINDOW and its right sibling,\n\
386 `vertical-line' is returned.")
387 (coordinates
, window
)
388 register Lisp_Object coordinates
, window
;
392 CHECK_LIVE_WINDOW (window
, 0);
393 CHECK_CONS (coordinates
, 1);
394 x
= XINT (Fcar (coordinates
));
395 y
= XINT (Fcdr (coordinates
));
397 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
399 case 0: /* NOT in window at all. */
402 case 1: /* In text part of window. */
405 case 2: /* In mode line of window. */
408 case 3: /* On right border of window. */
409 return Qvertical_line
;
416 /* Find the window containing column x, row y, and return it as a
417 Lisp_Object. If x, y is on the window's modeline, set *part
418 to 1; if it is on the separating line between the window and its
419 right sibling, set it to 2; otherwise set it to 0. If there is no
420 window under x, y return nil and leave *part unmodified. */
422 window_from_coordinates (frame
, x
, y
, part
)
427 register Lisp_Object tem
, first
;
429 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
433 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
441 tem
= Fnext_window (tem
, Qt
, Qlambda
);
443 while (! EQ (tem
, first
));
448 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
449 "Return window containing coordinates X and Y on FRAME.\n\
450 If omitted, FRAME defaults to the currently selected frame.\n\
451 The top left corner of the frame is considered to be row 0,\n\
454 Lisp_Object x
, y
, frame
;
460 XSETFRAME (frame
, selected_frame
);
462 CHECK_LIVE_FRAME (frame
, 2);
467 return window_from_coordinates (XFRAME (frame
),
472 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
473 "Return current value of point in WINDOW.\n\
474 For a nonselected window, this is the value point would have\n\
475 if that window were selected.\n\
477 Note that, when WINDOW is the selected window and its buffer\n\
478 is also currently selected, the value returned is the same as (point).\n\
479 It would be more strictly correct to return the `top-level' value\n\
480 of point, outside of any save-excursion forms.\n\
481 But that is hard to define.")
485 register struct window
*w
= decode_window (window
);
487 if (w
== XWINDOW (selected_window
)
488 && current_buffer
== XBUFFER (w
->buffer
))
490 return Fmarker_position (w
->pointm
);
493 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
494 "Return position at which display currently starts in WINDOW.")
498 return Fmarker_position (decode_window (window
)->start
);
501 /* This is text temporarily removed from the doc string below.
503 This function returns nil if the position is not currently known.\n\
504 That happens when redisplay is preempted and doesn't finish.\n\
505 If in that case you want to compute where the end of the window would\n\
506 have been if redisplay had finished, do this:\n\
508 (goto-char (window-start window))\n\
509 (vertical-motion (1- (window-height window)) window)\n\
512 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
513 "Return position at which display currently ends in WINDOW.\n\
514 This is updated by redisplay, when it runs to completion.\n\
515 Simply changing the buffer text or setting `window-start'\n\
516 does not update this value.")
521 struct window
*w
= decode_window (window
);
525 CHECK_BUFFER (buf
, 0);
527 #if 0 /* This change broke some things. We should make it later. */
528 /* If we don't know the end position, return nil.
529 The user can compute it with vertical-motion if he wants to.
530 It would be nicer to do it automatically,
531 but that's so slow that it would probably bother people. */
532 if (NILP (w
->window_end_valid
))
537 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
542 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
543 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
545 Lisp_Object window
, pos
;
547 register struct window
*w
= decode_window (window
);
549 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
550 if (w
== XWINDOW (selected_window
))
553 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
558 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
559 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
560 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
561 from overriding motion of point in order to display at this exact start.")
562 (window
, pos
, noforce
)
563 Lisp_Object window
, pos
, noforce
;
565 register struct window
*w
= decode_window (window
);
567 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
568 set_marker_restricted (w
->start
, pos
, w
->buffer
);
569 /* this is not right, but much easier than doing what is right. */
570 w
->start_at_line_beg
= Qnil
;
573 w
->update_mode_line
= Qt
;
574 XSETFASTINT (w
->last_modified
, 0);
575 if (!EQ (window
, selected_window
))
576 windows_or_buffers_changed
++;
580 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
582 "Return WINDOW's dedicated object, usually t or nil.\n\
583 See also `set-window-dedicated-p'.")
587 return decode_window (window
)->dedicated
;
590 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
591 Sset_window_dedicated_p
, 2, 2, 0,
592 "Control whether WINDOW is dedicated to the buffer it displays.\n\
593 If it is dedicated, Emacs will not automatically change\n\
594 which buffer appears in it.\n\
595 The second argument is the new value for the dedication flag;\n\
598 Lisp_Object window
, arg
;
600 register struct window
*w
= decode_window (window
);
610 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
612 "Return the display-table that WINDOW is using.")
616 return decode_window (window
)->display_table
;
619 /* Get the display table for use currently on window W.
620 This is either W's display table or W's buffer's display table.
621 Ignore the specified tables if they are not valid;
622 if no valid table is specified, return 0. */
625 window_display_table (w
)
629 tem
= w
->display_table
;
630 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
631 return XVECTOR (tem
);
632 tem
= XBUFFER (w
->buffer
)->display_table
;
633 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
634 return XVECTOR (tem
);
635 tem
= Vstandard_display_table
;
636 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
637 return XVECTOR (tem
);
641 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
642 "Set WINDOW's display-table to TABLE.")
644 register Lisp_Object window
, table
;
646 register struct window
*w
;
647 register Lisp_Object z
; /* Return value. */
649 w
= decode_window (window
);
650 w
->display_table
= table
;
654 /* Record info on buffer window w is displaying
655 when it is about to cease to display that buffer. */
658 register struct window
*w
;
663 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
667 if (w
== XWINDOW (selected_window
)
668 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
669 /* Do this except when the selected window's buffer
670 is being removed from some other window. */
672 /* last_window_start records the start position that this buffer
673 had in the last window to be disconnected from it.
674 Now that this statement is unconditional,
675 it is possible for the buffer to be displayed in the
676 selected window, while last_window_start reflects another
677 window which was recently showing the same buffer.
678 Some people might say that might be a good thing. Let's see. */
679 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
681 /* Point in the selected window's buffer
682 is actually stored in that buffer, and the window's pointm isn't used.
683 So don't clobber point in that buffer. */
684 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
685 BUF_PT (XBUFFER (buf
))
686 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
687 marker_position (w
->pointm
),
688 BUF_ZV (XBUFFER (buf
)));
691 /* Put replacement into the window structure in place of old. */
693 replace_window (old
, replacement
)
694 Lisp_Object old
, replacement
;
696 register Lisp_Object tem
;
697 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
699 /* If OLD is its frame's root_window, then replacement is the new
700 root_window for that frame. */
702 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
703 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
708 p
->height
= o
->height
;
710 p
->next
= tem
= o
->next
;
712 XWINDOW (tem
)->prev
= replacement
;
714 p
->prev
= tem
= o
->prev
;
716 XWINDOW (tem
)->next
= replacement
;
718 p
->parent
= tem
= o
->parent
;
721 if (EQ (XWINDOW (tem
)->vchild
, old
))
722 XWINDOW (tem
)->vchild
= replacement
;
723 if (EQ (XWINDOW (tem
)->hchild
, old
))
724 XWINDOW (tem
)->hchild
= replacement
;
727 /*** Here, if replacement is a vertical combination
728 and so is its new parent, we should make replacement's
729 children be children of that parent instead. ***/
732 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
733 "Remove WINDOW from the display. Default is selected window.")
735 register Lisp_Object window
;
737 register Lisp_Object tem
, parent
, sib
;
738 register struct window
*p
;
739 register struct window
*par
;
741 /* Because this function is called by other C code on non-leaf
742 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
743 so we can't decode_window here. */
745 window
= selected_window
;
747 CHECK_WINDOW (window
, 0);
748 p
= XWINDOW (window
);
750 /* It's okay to delete an already-deleted window. */
758 error ("Attempt to delete minibuffer or sole ordinary window");
759 par
= XWINDOW (parent
);
761 windows_or_buffers_changed
++;
762 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (p
))) = 1;
764 /* Are we trying to delete any frame's selected window? */
766 Lisp_Object frame
, pwindow
;
768 /* See if the frame's selected window is either WINDOW
769 or any subwindow of it, by finding all that window's parents
770 and comparing each one with WINDOW. */
771 frame
= WINDOW_FRAME (XWINDOW (window
));
772 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
774 while (!NILP (pwindow
))
776 if (EQ (window
, pwindow
))
778 pwindow
= XWINDOW (pwindow
)->parent
;
781 if (EQ (window
, pwindow
))
783 Lisp_Object alternative
;
784 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
786 /* If we're about to delete the selected window on the
787 selected frame, then we should use Fselect_window to select
788 the new window. On the other hand, if we're about to
789 delete the selected window on any other frame, we shouldn't do
790 anything but set the frame's selected_window slot. */
791 if (EQ (window
, selected_window
))
792 Fselect_window (alternative
);
794 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
799 /* tem is null for dummy parent windows
800 (which have inferiors but not any contents themselves) */
804 unchain_marker (p
->pointm
);
805 unchain_marker (p
->start
);
810 XWINDOW (tem
)->prev
= p
->prev
;
814 XWINDOW (tem
)->next
= p
->next
;
816 if (EQ (window
, par
->hchild
))
817 par
->hchild
= p
->next
;
818 if (EQ (window
, par
->vchild
))
819 par
->vchild
= p
->next
;
821 /* Find one of our siblings to give our space to. */
825 /* If p gives its space to its next sibling, that sibling needs
826 to have its top/left side pulled back to where p's is.
827 set_window_{height,width} will re-position the sibling's
830 XWINDOW (sib
)->top
= p
->top
;
831 XWINDOW (sib
)->left
= p
->left
;
834 /* Stretch that sibling. */
835 if (!NILP (par
->vchild
))
836 set_window_height (sib
,
837 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
839 if (!NILP (par
->hchild
))
840 set_window_width (sib
,
841 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
844 /* If parent now has only one child,
845 put the child into the parent's place. */
849 if (NILP (XWINDOW (tem
)->next
))
850 replace_window (parent
, tem
);
852 /* Since we may be deleting combination windows, we must make sure that
853 not only p but all its children have been marked as deleted. */
854 if (! NILP (p
->hchild
))
855 delete_all_subwindows (XWINDOW (p
->hchild
));
856 else if (! NILP (p
->vchild
))
857 delete_all_subwindows (XWINDOW (p
->vchild
));
859 /* Mark this window as deleted. */
860 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
866 extern Lisp_Object
next_frame (), prev_frame ();
868 /* This comment supplies the doc string for `next-window',
869 for make-docfile to see. We cannot put this in the real DEFUN
870 due to limits in the Unix cpp.
872 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
873 "Return next window after WINDOW in canonical ordering of windows.\n\
874 If omitted, WINDOW defaults to the selected window.\n\
876 Optional second arg MINIBUF t means count the minibuffer window even\n\
877 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
878 it is active. MINIBUF neither t nor nil means not to count the\n\
879 minibuffer even if it is active.\n\
881 Several frames may share a single minibuffer; if the minibuffer\n\
882 counts, all windows on all frames that share that minibuffer count\n\
883 too. Therefore, `next-window' can be used to iterate through the\n\
884 set of windows even when the minibuffer is on another frame. If the\n\
885 minibuffer does not count, only windows from WINDOW's frame count.\n\
887 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
888 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
889 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
890 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
891 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
892 Anything else means restrict to WINDOW's frame.\n\
894 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
895 `next-window' to iterate through the entire cycle of acceptable\n\
896 windows, eventually ending up back at the window you started with.\n\
897 `previous-window' traverses the same cycle, in the reverse order.")
898 (window, minibuf, all_frames) */
900 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
902 (window
, minibuf
, all_frames
)
903 register Lisp_Object window
, minibuf
, all_frames
;
905 register Lisp_Object tem
;
906 Lisp_Object start_window
;
909 window
= selected_window
;
911 CHECK_LIVE_WINDOW (window
, 0);
913 start_window
= window
;
915 /* minibuf == nil may or may not include minibuffers.
916 Decide if it does. */
918 minibuf
= (minibuf_level
? Qt
: Qlambda
);
921 /* all_frames == nil doesn't specify which frames to include. */
922 if (NILP (all_frames
))
923 all_frames
= (EQ (minibuf
, Qt
)
924 ? (FRAME_MINIBUF_WINDOW
927 (XWINDOW (window
)))))
929 else if (EQ (all_frames
, Qvisible
))
931 else if (XFASTINT (all_frames
) == 0)
933 else if (FRAMEP (all_frames
) && ! EQ (all_frames
, Fwindow_frame (window
)))
934 /* If all_frames is a frame and window arg isn't on that frame, just
935 return the first window on the frame. */
936 return Fframe_first_window (all_frames
);
937 else if (! EQ (all_frames
, Qt
))
939 /* Now all_frames is t meaning search all frames,
940 nil meaning search just current frame,
941 visible meaning search just visible frames,
942 0 meaning search visible and iconified frames,
943 or a window, meaning search the frame that window belongs to. */
946 /* Do this loop at least once, to get the next window, and perhaps
947 again, if we hit the minibuffer and that is not acceptable. */
950 /* Find a window that actually has a next one. This loop
951 climbs up the tree. */
952 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
953 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
957 /* We've reached the end of this frame.
958 Which other frames are acceptable? */
959 tem
= WINDOW_FRAME (XWINDOW (window
));
961 if (! NILP (all_frames
))
966 tem
= next_frame (tem
, all_frames
);
967 /* In the case where the minibuffer is active,
968 and we include its frame as well as the selected one,
969 next_frame may get stuck in that frame.
970 If that happens, go back to the selected frame
971 so we can complete the cycle. */
973 XSETFRAME (tem
, selected_frame
);
976 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
983 /* If we're in a combination window, find its first child and
984 recurse on that. Otherwise, we've found the window we want. */
987 if (!NILP (XWINDOW (window
)->hchild
))
988 window
= XWINDOW (window
)->hchild
;
989 else if (!NILP (XWINDOW (window
)->vchild
))
990 window
= XWINDOW (window
)->vchild
;
994 /* Which windows are acceptible?
995 Exit the loop and accept this window if
996 this isn't a minibuffer window, or
997 we're accepting minibuffer windows, or
998 we've come all the way around and we're back at the original window. */
999 while (MINI_WINDOW_P (XWINDOW (window
))
1000 && ! EQ (minibuf
, Qt
)
1001 && ! EQ (window
, start_window
));
1006 /* This comment supplies the doc string for `previous-window',
1007 for make-docfile to see. We cannot put this in the real DEFUN
1008 due to limits in the Unix cpp.
1010 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
1011 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
1012 If omitted, WINDOW defaults to the selected window.\n\
1014 Optional second arg MINIBUF t means count the minibuffer window even\n\
1015 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1016 it is active. MINIBUF neither t nor nil means not to count the\n\
1017 minibuffer even if it is active.\n\
1019 Several frames may share a single minibuffer; if the minibuffer\n\
1020 counts, all windows on all frames that share that minibuffer count\n\
1021 too. Therefore, `previous-window' can be used to iterate through\n\
1022 the set of windows even when the minibuffer is on another frame. If\n\
1023 the minibuffer does not count, only windows from WINDOW's frame count\n\
1025 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1026 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1027 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1028 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1029 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
1030 Anything else means restrict to WINDOW's frame.\n\
1032 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1033 `previous-window' to iterate through the entire cycle of acceptable\n\
1034 windows, eventually ending up back at the window you started with.\n\
1035 `next-window' traverses the same cycle, in the reverse order.")
1036 (window, minibuf, all_frames) */
1039 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1041 (window
, minibuf
, all_frames
)
1042 register Lisp_Object window
, minibuf
, all_frames
;
1044 register Lisp_Object tem
;
1045 Lisp_Object start_window
;
1048 window
= selected_window
;
1050 CHECK_LIVE_WINDOW (window
, 0);
1052 start_window
= window
;
1054 /* minibuf == nil may or may not include minibuffers.
1055 Decide if it does. */
1057 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1060 /* all_frames == nil doesn't specify which frames to include.
1061 Decide which frames it includes. */
1062 if (NILP (all_frames
))
1063 all_frames
= (EQ (minibuf
, Qt
)
1064 ? (FRAME_MINIBUF_WINDOW
1067 (XWINDOW (window
)))))
1069 else if (EQ (all_frames
, Qvisible
))
1071 else if (XFASTINT (all_frames
) == 0)
1073 else if (FRAMEP (all_frames
) && ! EQ (all_frames
, Fwindow_frame (window
)))
1074 /* If all_frames is a frame and window arg isn't on that frame, just
1075 return the first window on the frame. */
1076 return Fframe_first_window (all_frames
);
1077 else if (! EQ (all_frames
, Qt
))
1079 /* Now all_frames is t meaning search all frames,
1080 nil meaning search just current frame,
1081 visible meaning search just visible frames,
1082 0 meaning search visible and iconified frames,
1083 or a window, meaning search the frame that window belongs to. */
1086 /* Do this loop at least once, to get the previous window, and perhaps
1087 again, if we hit the minibuffer and that is not acceptable. */
1090 /* Find a window that actually has a previous one. This loop
1091 climbs up the tree. */
1092 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1093 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1097 /* We have found the top window on the frame.
1098 Which frames are acceptable? */
1099 tem
= WINDOW_FRAME (XWINDOW (window
));
1101 if (! NILP (all_frames
))
1102 /* It's actually important that we use prev_frame here,
1103 rather than next_frame. All the windows acceptable
1104 according to the given parameters should form a ring;
1105 Fnext_window and Fprevious_window should go back and
1106 forth around the ring. If we use next_frame here,
1107 then Fnext_window and Fprevious_window take different
1108 paths through the set of acceptable windows.
1109 window_loop assumes that these `ring' requirement are
1115 tem
= prev_frame (tem
, all_frames
);
1116 /* In the case where the minibuffer is active,
1117 and we include its frame as well as the selected one,
1118 next_frame may get stuck in that frame.
1119 If that happens, go back to the selected frame
1120 so we can complete the cycle. */
1122 XSETFRAME (tem
, selected_frame
);
1125 /* If this frame has a minibuffer, find that window first,
1126 because it is conceptually the last window in that frame. */
1127 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1128 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1130 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1136 /* If we're in a combination window, find its last child and
1137 recurse on that. Otherwise, we've found the window we want. */
1140 if (!NILP (XWINDOW (window
)->hchild
))
1141 window
= XWINDOW (window
)->hchild
;
1142 else if (!NILP (XWINDOW (window
)->vchild
))
1143 window
= XWINDOW (window
)->vchild
;
1145 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1149 /* Which windows are acceptable?
1150 Exit the loop and accept this window if
1151 this isn't a minibuffer window, or
1152 we're accepting minibuffer windows, or
1153 we've come all the way around and we're back at the original window. */
1154 while (MINI_WINDOW_P (XWINDOW (window
))
1155 && !EQ (minibuf
, Qt
)
1156 && !EQ (window
, start_window
));
1161 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1162 "Select the ARG'th different window on this frame.\n\
1163 All windows on current frame are arranged in a cyclic order.\n\
1164 This command selects the window ARG steps away in that order.\n\
1165 A negative ARG moves in the opposite order. If the optional second\n\
1166 argument ALL_FRAMES is non-nil, cycle through all frames.")
1168 register Lisp_Object n
, all_frames
;
1171 register Lisp_Object w
;
1173 CHECK_NUMBER (n
, 0);
1174 w
= selected_window
;
1179 w
= Fnext_window (w
, Qnil
, all_frames
);
1184 w
= Fprevious_window (w
, Qnil
, all_frames
);
1191 /* Look at all windows, performing an operation specified by TYPE
1193 If FRAMES is Qt, look at all frames;
1194 Qnil, look at just the selected frame;
1195 Qvisible, look at visible frames;
1196 a frame, just look at windows on that frame.
1197 If MINI is non-zero, perform the operation on minibuffer windows too.
1203 GET_BUFFER_WINDOW
, /* Arg is buffer */
1204 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1205 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1206 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1208 UNSHOW_BUFFER
/* Arg is buffer */
1212 window_loop (type
, obj
, mini
, frames
)
1213 enum window_loop type
;
1214 register Lisp_Object obj
, frames
;
1217 register Lisp_Object w
;
1218 register Lisp_Object best_window
;
1219 register Lisp_Object next_window
;
1220 register Lisp_Object last_window
;
1222 Lisp_Object frame_arg
;
1226 /* If we're only looping through windows on a particular frame,
1227 frame points to that frame. If we're looping through windows
1228 on all frames, frame is 0. */
1229 if (FRAMEP (frames
))
1230 frame
= XFRAME (frames
);
1231 else if (NILP (frames
))
1232 frame
= selected_frame
;
1236 frame_arg
= Qlambda
;
1237 else if (XFASTINT (frames
) == 0)
1239 else if (EQ (frames
, Qvisible
))
1245 /* frame_arg is Qlambda to stick to one frame,
1246 Qvisible to consider all visible frames,
1249 /* Pick a window to start with. */
1253 w
= FRAME_SELECTED_WINDOW (frame
);
1255 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1257 /* Figure out the last window we're going to mess with. Since
1258 Fnext_window, given the same options, is guaranteed to go in a
1259 ring, we can just use Fprevious_window to find the last one.
1261 We can't just wait until we hit the first window again, because
1262 it might be deleted. */
1264 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1269 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1271 /* Pick the next window now, since some operations will delete
1272 the current window. */
1273 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1275 /* Note that we do not pay attention here to whether
1276 the frame is visible, since Fnext_window skips non-visible frames
1277 if that is desired, under the control of frame_arg. */
1278 if (! MINI_WINDOW_P (XWINDOW (w
))
1279 || (mini
&& minibuf_level
> 0))
1282 case GET_BUFFER_WINDOW
:
1283 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1287 case GET_LRU_WINDOW
:
1288 /* t as arg means consider only full-width windows */
1289 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1290 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1292 /* Ignore dedicated windows and minibuffers. */
1293 if (MINI_WINDOW_P (XWINDOW (w
))
1294 || !NILP (XWINDOW (w
)->dedicated
))
1296 if (NILP (best_window
)
1297 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1298 > XFASTINT (XWINDOW (w
)->use_time
)))
1302 case DELETE_OTHER_WINDOWS
:
1303 if (XWINDOW (w
) != XWINDOW (obj
))
1307 case DELETE_BUFFER_WINDOWS
:
1308 if (EQ (XWINDOW (w
)->buffer
, obj
))
1311 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1313 /* If this window is dedicated, and in a frame of its own,
1315 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1316 && !NILP (XWINDOW (w
)->dedicated
)
1317 && other_visible_frames (f
))
1319 /* Skip the other windows on this frame.
1320 There might be one, the minibuffer! */
1321 if (! EQ (w
, last_window
))
1322 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1324 /* As we go, check for the end of the loop.
1325 We mustn't start going around a second time. */
1326 if (EQ (next_window
, last_window
))
1331 next_window
= Fnext_window (next_window
,
1335 /* Now we can safely delete the frame. */
1336 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1340 /* If we're deleting the buffer displayed in the only window
1341 on the frame, find a new buffer to display there. */
1342 if (NILP (XWINDOW (w
)->parent
))
1344 Lisp_Object new_buffer
;
1345 new_buffer
= Fother_buffer (obj
, Qnil
);
1346 if (NILP (new_buffer
))
1348 = Fget_buffer_create (build_string ("*scratch*"));
1349 Fset_window_buffer (w
, new_buffer
);
1350 if (EQ (w
, selected_window
))
1351 Fset_buffer (XWINDOW (w
)->buffer
);
1358 case GET_LARGEST_WINDOW
:
1359 /* Ignore dedicated windows and minibuffers. */
1360 if (MINI_WINDOW_P (XWINDOW (w
))
1361 || !NILP (XWINDOW (w
)->dedicated
))
1364 struct window
*best_window_ptr
= XWINDOW (best_window
);
1365 struct window
*w_ptr
= XWINDOW (w
);
1366 if (NILP (best_window
)
1367 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1368 > (XFASTINT (best_window_ptr
->height
)
1369 * XFASTINT (best_window_ptr
->width
))))
1375 if (EQ (XWINDOW (w
)->buffer
, obj
))
1377 /* Find another buffer to show in this window. */
1378 Lisp_Object another_buffer
;
1379 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1380 another_buffer
= Fother_buffer (obj
, Qnil
);
1381 if (NILP (another_buffer
))
1383 = Fget_buffer_create (build_string ("*scratch*"));
1385 /* If this window is dedicated, and in a frame of its own,
1387 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1388 && !NILP (XWINDOW (w
)->dedicated
)
1389 && other_visible_frames (f
))
1391 /* Skip the other windows on this frame.
1392 There might be one, the minibuffer! */
1393 if (! EQ (w
, last_window
))
1394 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1396 /* As we go, check for the end of the loop.
1397 We mustn't start going around a second time. */
1398 if (EQ (next_window
, last_window
))
1403 next_window
= Fnext_window (next_window
,
1407 /* Now we can safely delete the frame. */
1408 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1413 /* Otherwise show a different buffer in the window. */
1414 XWINDOW (w
)->dedicated
= Qnil
;
1415 Fset_window_buffer (w
, another_buffer
);
1416 if (EQ (w
, selected_window
))
1417 Fset_buffer (XWINDOW (w
)->buffer
);
1423 if (EQ (w
, last_window
))
1432 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1433 "Return the window least recently selected or used for display.\n\
1434 If optional argument FRAME is `visible', search all visible frames.\n\
1435 If FRAME is 0, search all visible and iconified frames.\n\
1436 If FRAME is t, search all frames.\n\
1437 If FRAME is nil, search only the selected frame.\n\
1438 If FRAME is a frame, search only that frame.")
1442 register Lisp_Object w
;
1443 /* First try for a window that is full-width */
1444 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1445 if (!NILP (w
) && !EQ (w
, selected_window
))
1447 /* If none of them, try the rest */
1448 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1451 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1452 "Return the largest window in area.\n\
1453 If optional argument FRAME is `visible', search all visible frames.\n\
1454 If FRAME is 0, search all visible and iconified frames.\n\
1455 If FRAME is t, search all frames.\n\
1456 If FRAME is nil, search only the selected frame.\n\
1457 If FRAME is a frame, search only that frame.")
1461 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1465 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1466 "Return a window currently displaying BUFFER, or nil if none.\n\
1467 If optional argument FRAME is `visible', search all visible frames.\n\
1468 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1469 If FRAME is t, search all frames.\n\
1470 If FRAME is nil, search only the selected frame.\n\
1471 If FRAME is a frame, search only that frame.")
1473 Lisp_Object buffer
, frame
;
1475 buffer
= Fget_buffer (buffer
);
1476 if (BUFFERP (buffer
))
1477 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1482 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1484 "Make WINDOW (or the selected window) fill its frame.\n\
1485 Only the frame WINDOW is on is affected.\n\
1486 This function tries to reduce display jumps\n\
1487 by keeping the text previously visible in WINDOW\n\
1488 in the same place on the frame. Doing this depends on\n\
1489 the value of (window-start WINDOW), so if calling this function\n\
1490 in a program gives strange scrolling, make sure the window-start\n\
1491 value is reasonable when this function is called.")
1500 window
= selected_window
;
1502 CHECK_LIVE_WINDOW (window
, 0);
1504 w
= XWINDOW (window
);
1506 startpos
= marker_position (w
->start
);
1507 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1509 if (MINI_WINDOW_P (w
) && top
> 0)
1510 error ("Can't expand minibuffer to full frame");
1512 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1514 /* Try to minimize scrolling, by setting the window start to the point
1515 will cause the text at the old window start to be at the same place
1516 on the frame. But don't try to do this if the window start is
1517 outside the visible portion (as might happen when the display is
1518 not current, due to typeahead). */
1519 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1520 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1522 struct position pos
;
1523 struct buffer
*obuf
= current_buffer
;
1525 Fset_buffer (w
->buffer
);
1526 /* This computation used to temporarily move point, but that can
1527 have unwanted side effects due to text properties. */
1528 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1529 XINT (w
->hscroll
), window
);
1530 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1531 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1532 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1535 set_buffer_internal (obuf
);
1540 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1541 1, 2, "bDelete windows on (buffer): ",
1542 "Delete all windows showing BUFFER.\n\
1543 Optional second argument FRAME controls which frames are affected.\n\
1544 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1545 If t, delete only windows showing BUFFER in the selected frame.\n\
1546 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1547 If a frame, delete only windows showing BUFFER in that frame.")
1549 Lisp_Object buffer
, frame
;
1552 /* FRAME uses t and nil to mean the opposite of what window_loop
1554 if (! FRAMEP (frame
))
1555 frame
= NILP (frame
) ? Qt
: Qnil
;
1562 buffer
= Fget_buffer (buffer
);
1563 CHECK_BUFFER (buffer
, 0);
1564 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1569 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1570 Sreplace_buffer_in_windows
,
1571 1, 1, "bReplace buffer in windows: ",
1572 "Replace BUFFER with some other buffer in all windows showing it.")
1578 buffer
= Fget_buffer (buffer
);
1579 CHECK_BUFFER (buffer
, 0);
1580 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1585 /* Set the height of WINDOW and all its inferiors. */
1587 /* The smallest acceptable dimensions for a window. Anything smaller
1588 might crash Emacs. */
1589 #define MIN_SAFE_WINDOW_WIDTH (2)
1590 #define MIN_SAFE_WINDOW_HEIGHT (2)
1592 /* Make sure that window_min_height and window_min_width are
1593 not too small; if they are, set them to safe minima. */
1596 check_min_window_sizes ()
1598 /* Smaller values might permit a crash. */
1599 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1600 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1601 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1602 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1605 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1606 minimum allowable size. */
1608 check_frame_size (frame
, rows
, cols
)
1612 /* For height, we have to see:
1613 whether the frame has a minibuffer,
1614 whether it wants a mode line, and
1615 whether it has a menu bar. */
1617 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1618 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1619 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1620 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1621 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1623 if (*rows
< min_height
)
1625 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1626 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1629 /* Normally the window is deleted if it gets too small.
1630 nodelete nonzero means do not do this.
1631 (The caller should check later and do so if appropriate) */
1633 set_window_height (window
, height
, nodelete
)
1638 register struct window
*w
= XWINDOW (window
);
1639 register struct window
*c
;
1640 int oheight
= XFASTINT (w
->height
);
1641 int top
, pos
, lastbot
, opos
, lastobot
;
1644 check_min_window_sizes ();
1647 && ! NILP (w
->parent
)
1648 && height
< window_min_height
)
1650 Fdelete_window (window
);
1654 XSETFASTINT (w
->last_modified
, 0);
1655 windows_or_buffers_changed
++;
1656 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1658 XSETFASTINT (w
->height
, height
);
1659 if (!NILP (w
->hchild
))
1661 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1663 XWINDOW (child
)->top
= w
->top
;
1664 set_window_height (child
, height
, nodelete
);
1667 else if (!NILP (w
->vchild
))
1669 lastbot
= top
= XFASTINT (w
->top
);
1671 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1673 c
= XWINDOW (child
);
1675 opos
= lastobot
+ XFASTINT (c
->height
);
1677 XSETFASTINT (c
->top
, lastbot
);
1679 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1681 /* Avoid confusion: inhibit deletion of child if becomes too small */
1682 set_window_height (child
, pos
+ top
- lastbot
, 1);
1684 /* Now advance child to next window,
1685 and set lastbot if child was not just deleted. */
1686 lastbot
= pos
+ top
;
1689 /* Now delete any children that became too small. */
1691 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1693 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1698 /* Recursively set width of WINDOW and its inferiors. */
1700 set_window_width (window
, width
, nodelete
)
1705 register struct window
*w
= XWINDOW (window
);
1706 register struct window
*c
;
1707 int owidth
= XFASTINT (w
->width
);
1708 int left
, pos
, lastright
, opos
, lastoright
;
1711 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1713 Fdelete_window (window
);
1717 XSETFASTINT (w
->last_modified
, 0);
1718 windows_or_buffers_changed
++;
1719 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1721 XSETFASTINT (w
->width
, width
);
1722 if (!NILP (w
->vchild
))
1724 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1726 XWINDOW (child
)->left
= w
->left
;
1727 set_window_width (child
, width
, nodelete
);
1730 else if (!NILP (w
->hchild
))
1732 lastright
= left
= XFASTINT (w
->left
);
1734 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1736 c
= XWINDOW (child
);
1738 opos
= lastoright
+ XFASTINT (c
->width
);
1740 XSETFASTINT (c
->left
, lastright
);
1742 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1744 /* Inhibit deletion for becoming too small */
1745 set_window_width (child
, pos
+ left
- lastright
, 1);
1747 /* Now advance child to next window,
1748 and set lastright if child was not just deleted. */
1749 lastright
= pos
+ left
, lastoright
= opos
;
1751 /* Delete children that became too small */
1753 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1755 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1760 int window_select_count
;
1762 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1763 "Make WINDOW display BUFFER as its contents.\n\
1764 BUFFER can be a buffer or buffer name.")
1766 register Lisp_Object window
, buffer
;
1768 register Lisp_Object tem
;
1769 register struct window
*w
= decode_window (window
);
1771 buffer
= Fget_buffer (buffer
);
1772 CHECK_BUFFER (buffer
, 1);
1774 if (NILP (XBUFFER (buffer
)->name
))
1775 error ("Attempt to display deleted buffer");
1779 error ("Window is deleted");
1780 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1781 is first being set up. */
1783 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1784 error ("Window is dedicated to `%s'",
1785 XSTRING (XBUFFER (tem
)->name
)->data
);
1791 XSETFASTINT (w
->window_end_pos
, 0);
1792 w
->window_end_valid
= Qnil
;
1793 XSETFASTINT(w
->hscroll
, 0);
1794 Fset_marker (w
->pointm
,
1795 make_number (BUF_PT (XBUFFER (buffer
))),
1797 set_marker_restricted (w
->start
,
1798 make_number (XBUFFER (buffer
)->last_window_start
),
1800 w
->start_at_line_beg
= Qnil
;
1801 w
->force_start
= Qnil
;
1802 XSETFASTINT (w
->last_modified
, 0);
1803 windows_or_buffers_changed
++;
1804 if (EQ (window
, selected_window
))
1805 Fset_buffer (buffer
);
1810 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1811 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1812 The main editor command loop selects the buffer of the selected window\n\
1813 before each command.")
1815 register Lisp_Object window
;
1817 register struct window
*w
;
1818 register struct window
*ow
= XWINDOW (selected_window
);
1820 CHECK_LIVE_WINDOW (window
, 0);
1822 w
= XWINDOW (window
);
1824 if (NILP (w
->buffer
))
1825 error ("Trying to select deleted window or non-leaf window");
1827 XSETFASTINT (w
->use_time
, ++window_select_count
);
1828 if (EQ (window
, selected_window
))
1831 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1834 selected_window
= window
;
1836 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1838 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1839 /* Use this rather than Fhandle_switch_frame
1840 so that FRAME_FOCUS_FRAME is moved appropriately as we
1841 move around in the state where a minibuffer in a separate
1843 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1846 selected_frame
->selected_window
= window
;
1849 record_buffer (w
->buffer
);
1850 Fset_buffer (w
->buffer
);
1852 /* Go to the point recorded in the window.
1853 This is important when the buffer is in more
1854 than one window. It also matters when
1855 redisplay_window has altered point after scrolling,
1856 because it makes the change only in the window. */
1858 register int new_point
= marker_position (w
->pointm
);
1859 if (new_point
< BEGV
)
1861 else if (new_point
> ZV
)
1867 windows_or_buffers_changed
++;
1871 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1872 "bDisplay buffer: \nP",
1873 "Make BUFFER appear in some window but don't select it.\n\
1874 BUFFER can be a buffer or a buffer name.\n\
1875 If BUFFER is shown already in some window, just use that one,\n\
1876 unless the window is the selected window and the optional second\n\
1877 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1878 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1879 Returns the window displaying BUFFER.")
1880 (buffer
, not_this_window
)
1881 register Lisp_Object buffer
, not_this_window
;
1883 register Lisp_Object window
, tem
;
1885 buffer
= Fget_buffer (buffer
);
1886 CHECK_BUFFER (buffer
, 0);
1888 if (!NILP (Vdisplay_buffer_function
))
1889 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1891 if (NILP (not_this_window
)
1892 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1893 return selected_window
;
1895 /* See if the user has specified this buffer should appear
1896 in the selected window. */
1897 if (NILP (not_this_window
))
1899 tem
= Fmember (XBUFFER (buffer
)->name
, Vsame_window_buffer_names
);
1902 Fswitch_to_buffer (buffer
, Qnil
);
1903 return selected_window
;
1906 tem
= Fassoc (XBUFFER (buffer
)->name
, Vsame_window_buffer_names
);
1909 Fswitch_to_buffer (buffer
, Qnil
);
1910 return selected_window
;
1913 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1915 Lisp_Object car
= XCONS (tem
)->car
;
1917 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1919 Fswitch_to_buffer (buffer
, Qnil
);
1920 return selected_window
;
1922 else if (CONSP (car
)
1923 && STRINGP (XCONS (car
)->car
)
1924 && fast_string_match (XCONS (car
)->car
,
1925 XBUFFER (buffer
)->name
) >= 0)
1927 Fswitch_to_buffer (buffer
, Qnil
);
1928 return selected_window
;
1934 /* If pop_up_frames,
1935 look for a window showing BUFFER on any visible or iconified frame.
1936 Otherwise search only the current frame. */
1937 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1938 XSETFASTINT (tem
, 0);
1941 XSETFRAME (tem
, last_nonminibuf_frame
);
1942 window
= Fget_buffer_window (buffer
, tem
);
1944 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1947 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1948 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1953 /* Certain buffer names get special handling. */
1954 if (! NILP (Vspecial_display_function
))
1956 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1958 return call1 (Vspecial_display_function
, buffer
);
1960 tem
= Fassoc (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1962 return call2 (Vspecial_display_function
, buffer
, XCONS (tem
)->cdr
);
1964 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1966 Lisp_Object car
= XCONS (tem
)->car
;
1968 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1969 return call1 (Vspecial_display_function
, buffer
);
1970 else if (CONSP (car
)
1971 && STRINGP (XCONS (car
)->car
)
1972 && fast_string_match (XCONS (car
)->car
,
1973 XBUFFER (buffer
)->name
) >= 0)
1974 return call2 (Vspecial_display_function
,
1981 /* If there are no frames open that have more than a minibuffer,
1982 we need to create a new frame. */
1983 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1985 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1986 Fset_window_buffer (window
, buffer
);
1989 #endif /* MULTI_FRAME */
1993 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1994 /* If the current frame is a special display frame,
1995 don't try to reuse its windows. */
1996 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
2004 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
2005 XSETFRAME (frames
, last_nonminibuf_frame
);
2007 /* Don't try to create a window if would get an error */
2008 if (split_height_threshold
< window_min_height
<< 1)
2009 split_height_threshold
= window_min_height
<< 1;
2011 /* Note that both Fget_largest_window and Fget_lru_window
2012 ignore minibuffers and dedicated windows.
2013 This means they can return nil. */
2016 /* If the frame we would try to split cannot be split,
2017 try other frames. */
2018 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
2019 : last_nonminibuf_frame
))
2021 /* Try visible frames first. */
2022 window
= Fget_largest_window (Qvisible
);
2023 /* If that didn't work, try iconified frames. */
2025 window
= Fget_largest_window (make_number (0));
2027 window
= Fget_largest_window (Qt
);
2031 window
= Fget_largest_window (frames
);
2033 /* If we got a tall enough full-width window that can be split,
2036 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2037 && window_height (window
) >= split_height_threshold
2038 && (XFASTINT (XWINDOW (window
)->width
)
2039 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
2040 window
= Fsplit_window (window
, Qnil
, Qnil
);
2043 Lisp_Object upper
, lower
, other
;
2045 window
= Fget_lru_window (frames
);
2046 /* If the LRU window is selected, and big enough,
2047 and can be split, split it. */
2049 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2050 && (EQ (window
, selected_window
)
2051 || EQ (XWINDOW (window
)->parent
, Qnil
))
2052 && window_height (window
) >= window_min_height
<< 1)
2053 window
= Fsplit_window (window
, Qnil
, Qnil
);
2055 /* If Fget_lru_window returned nil, try other approaches. */
2056 /* Try visible frames first. */
2058 window
= Fget_largest_window (Qvisible
);
2059 /* If that didn't work, try iconified frames. */
2061 window
= Fget_largest_window (make_number (0));
2062 /* Try invisible frames. */
2064 window
= Fget_largest_window (Qt
);
2065 /* As a last resort, make a new frame. */
2067 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2069 /* As a last resort, use a non minibuffer window. */
2071 window
= Fframe_first_window (Fselected_frame ());
2073 /* If window appears above or below another,
2074 even out their heights. */
2075 other
= upper
= lower
= Qnil
;
2076 if (!NILP (XWINDOW (window
)->prev
))
2077 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
2078 if (!NILP (XWINDOW (window
)->next
))
2079 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
2081 /* Check that OTHER and WINDOW are vertically arrayed. */
2082 && XWINDOW (other
)->top
!= XWINDOW (window
)->top
2083 && XWINDOW (other
)->height
> XWINDOW (window
)->height
)
2085 int total
= XWINDOW (other
)->height
+ XWINDOW (window
)->height
;
2086 Lisp_Object old_selected_window
;
2087 old_selected_window
= selected_window
;
2089 selected_window
= upper
;
2090 change_window_height (total
/ 2 - XWINDOW (upper
)->height
, 0);
2091 selected_window
= old_selected_window
;
2096 window
= Fget_lru_window (Qnil
);
2098 Fset_window_buffer (window
, buffer
);
2103 temp_output_buffer_show (buf
)
2104 register Lisp_Object buf
;
2106 register struct buffer
*old
= current_buffer
;
2107 register Lisp_Object window
;
2108 register struct window
*w
;
2111 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
2116 set_buffer_internal (old
);
2118 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
2119 call1 (Vtemp_buffer_show_function
, buf
);
2122 window
= Fdisplay_buffer (buf
, Qnil
);
2125 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2126 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2127 #endif /* MULTI_FRAME */
2128 Vminibuf_scroll_window
= window
;
2129 w
= XWINDOW (window
);
2130 XSETFASTINT (w
->hscroll
, 0);
2131 set_marker_restricted (w
->start
, make_number (1), buf
);
2132 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2134 /* Run temp-buffer-show-hook, with the chosen window selected. */
2135 if (!NILP (Vrun_hooks
))
2138 tem
= Fboundp (Qtemp_buffer_show_hook
);
2141 tem
= Fsymbol_value (Qtemp_buffer_show_hook
);
2144 int count
= specpdl_ptr
- specpdl
;
2146 /* Select the window that was chosen, for running the hook. */
2147 record_unwind_protect (Fset_window_configuration
,
2148 Fcurrent_window_configuration (Qnil
));
2150 Fselect_window (window
);
2151 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
2152 unbind_to (count
, Qnil
);
2160 make_dummy_parent (window
)
2164 register struct window
*o
, *p
;
2165 register struct Lisp_Vector
*vec
;
2168 o
= XWINDOW (window
);
2169 vec
= allocate_vectorlike ((EMACS_INT
)VECSIZE (struct window
));
2170 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
2171 vec
->contents
[i
] = ((struct Lisp_Vector
*)o
)->contents
[i
];
2172 vec
->size
= VECSIZE (struct window
);
2173 p
= (struct window
*)vec
;
2174 XSETWINDOW (new, p
);
2176 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
2178 /* Put new into window structure in place of window */
2179 replace_window (window
, new);
2192 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2193 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2194 WINDOW defaults to selected one and SIZE to half its size.\n\
2195 If optional third arg HOR-FLAG is non-nil, split side by side\n\
2196 and put SIZE columns in the first of the pair.")
2197 (window
, chsize
, horflag
)
2198 Lisp_Object window
, chsize
, horflag
;
2200 register Lisp_Object
new;
2201 register struct window
*o
, *p
;
2205 window
= selected_window
;
2207 CHECK_LIVE_WINDOW (window
, 0);
2209 o
= XWINDOW (window
);
2213 if (!NILP (horflag
))
2214 /* Round odd size up, since this is for the left-hand window,
2215 and it will lose a column for the separators. */
2216 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
2218 size
= XFASTINT (o
->height
) >> 1;
2222 CHECK_NUMBER (chsize
, 1);
2223 size
= XINT (chsize
);
2226 if (MINI_WINDOW_P (o
))
2227 error ("Attempt to split minibuffer window");
2228 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
2229 error ("Attempt to split unsplittable frame");
2231 check_min_window_sizes ();
2235 if (size
< window_min_height
2236 || size
+ window_min_height
> XFASTINT (o
->height
))
2237 args_out_of_range_3 (window
, chsize
, horflag
);
2238 if (NILP (o
->parent
)
2239 || NILP (XWINDOW (o
->parent
)->vchild
))
2241 make_dummy_parent (window
);
2243 XWINDOW (new)->vchild
= window
;
2248 if (size
< window_min_width
2249 || size
+ window_min_width
> XFASTINT (o
->width
))
2250 args_out_of_range_3 (window
, chsize
, horflag
);
2251 if (NILP (o
->parent
)
2252 || NILP (XWINDOW (o
->parent
)->hchild
))
2254 make_dummy_parent (window
);
2256 XWINDOW (new)->hchild
= window
;
2260 /* Now we know that window's parent is a vertical combination
2261 if we are dividing vertically, or a horizontal combination
2262 if we are making side-by-side windows */
2264 windows_or_buffers_changed
++;
2265 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (o
))) = 1;
2266 new = make_window ();
2269 p
->frame
= o
->frame
;
2271 if (!NILP (p
->next
))
2272 XWINDOW (p
->next
)->prev
= new;
2275 p
->parent
= o
->parent
;
2278 Fset_window_buffer (new, o
->buffer
);
2280 /* Apportion the available frame space among the two new windows */
2282 if (!NILP (horflag
))
2284 p
->height
= o
->height
;
2286 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size
);
2287 XSETFASTINT (o
->width
, size
);
2288 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size
);
2293 p
->width
= o
->width
;
2294 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size
);
2295 XSETFASTINT (o
->height
, size
);
2296 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size
);
2302 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2303 "Make current window ARG lines bigger.\n\
2304 From program, optional second arg non-nil means grow sideways ARG columns.")
2306 register Lisp_Object n
, side
;
2308 CHECK_NUMBER (n
, 0);
2309 change_window_height (XINT (n
), !NILP (side
));
2313 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2314 "Make current window ARG lines smaller.\n\
2315 From program, optional second arg non-nil means shrink sideways ARG columns.")
2317 register Lisp_Object n
, side
;
2319 CHECK_NUMBER (n
, 0);
2320 change_window_height (-XINT (n
), !NILP (side
));
2325 window_height (window
)
2328 register struct window
*p
= XWINDOW (window
);
2329 return XFASTINT (p
->height
);
2333 window_width (window
)
2336 register struct window
*p
= XWINDOW (window
);
2337 return XFASTINT (p
->width
);
2340 #define MINSIZE(w) \
2342 ? window_min_width \
2343 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2346 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2348 #define CURSIZE(w) \
2349 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2351 /* Unlike set_window_height, this function
2352 also changes the heights of the siblings so as to
2353 keep everything consistent. */
2355 change_window_height (delta
, widthflag
)
2359 register Lisp_Object parent
;
2361 register struct window
*p
;
2363 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2364 register int (*setsizefun
) () = (widthflag
2366 : set_window_height
);
2368 check_min_window_sizes ();
2370 window
= selected_window
;
2373 p
= XWINDOW (window
);
2378 error ("No other window to side of this one");
2381 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2382 : !NILP (XWINDOW (parent
)->vchild
))
2387 sizep
= &CURSIZE (window
);
2390 register int maxdelta
;
2392 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2393 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2394 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2395 /* This is a frame with only one window, a minibuffer-only
2396 or a minibufferless frame. */
2399 if (delta
> maxdelta
)
2400 /* This case traps trying to make the minibuffer
2401 the full frame, or make the only window aside from the
2402 minibuffer the full frame. */
2406 if (*sizep
+ delta
< MINSIZE (window
))
2408 Fdelete_window (window
);
2416 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2418 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2419 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2420 CURBEG (p
->next
) += delta
;
2421 /* This does not change size of p->next,
2422 but it propagates the new top edge to its children */
2423 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2425 else if (!NILP (p
->prev
)
2426 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2428 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2429 CURBEG (window
) -= delta
;
2430 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2434 register int delta1
;
2435 register int opht
= (*sizefun
) (parent
);
2437 /* If trying to grow this window to or beyond size of the parent,
2438 make delta1 so big that, on shrinking back down,
2439 all the siblings end up with less than one line and are deleted. */
2440 if (opht
<= *sizep
+ delta
)
2441 delta1
= opht
* opht
* 2;
2442 /* Otherwise, make delta1 just right so that if we add delta1
2443 lines to this window and to the parent, and then shrink
2444 the parent back to its original size, the new proportional
2445 size of this window will increase by delta. */
2447 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2449 /* Add delta1 lines or columns to this window, and to the parent,
2450 keeping things consistent while not affecting siblings. */
2451 CURSIZE (parent
) = opht
+ delta1
;
2452 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2454 /* Squeeze out delta1 lines or columns from our parent,
2455 shriking this window and siblings proportionately.
2456 This brings parent back to correct size.
2457 Delta1 was calculated so this makes this window the desired size,
2458 taking it all out of the siblings. */
2459 (*setsizefun
) (parent
, opht
, 0);
2462 XSETFASTINT (p
->last_modified
, 0);
2469 /* Return number of lines of text (not counting mode line) in W. */
2472 window_internal_height (w
)
2475 int ht
= XFASTINT (w
->height
);
2477 if (MINI_WINDOW_P (w
))
2480 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2481 || !NILP (w
->next
) || !NILP (w
->prev
)
2482 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2489 /* Return the number of columns in W.
2490 Don't count columns occupied by scroll bars or the vertical bar
2491 separating W from the sibling to its right. */
2493 window_internal_width (w
)
2496 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2497 int left
= XINT (w
->left
);
2498 int width
= XINT (w
->width
);
2500 /* If this window is flush against the right edge of the frame, its
2501 internal width is its full width. */
2502 if (left
+ width
>= FRAME_WIDTH (f
))
2505 /* If we are not flush right, then our rightmost columns are
2506 occupied by some sort of separator. */
2508 /* Scroll bars occupy a few columns. */
2509 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2510 return width
- FRAME_SCROLL_BAR_COLS (f
);
2512 /* The column of `|' characters separating side-by-side windows
2513 occupies one column only. */
2518 /* Scroll contents of window WINDOW up N lines. */
2521 window_scroll (window
, n
, noerror
)
2526 register struct window
*w
= XWINDOW (window
);
2527 register int opoint
= PT
;
2529 register int ht
= window_internal_height (w
);
2530 register Lisp_Object tem
;
2532 Lisp_Object bolp
, nmoved
;
2534 XSETFASTINT (tem
, PT
);
2535 tem
= Fpos_visible_in_window_p (tem
, window
);
2539 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2540 XSETFASTINT (tem
, PT
);
2541 Fset_marker (w
->start
, tem
, w
->buffer
);
2542 w
->force_start
= Qt
;
2545 SET_PT (marker_position (w
->start
));
2546 lose
= n
< 0 && PT
== BEGV
;
2547 Fvertical_motion (make_number (n
), window
);
2557 Fsignal (Qbeginning_of_buffer
, Qnil
);
2562 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2563 w
->start_at_line_beg
= bolp
;
2564 w
->update_mode_line
= Qt
;
2565 XSETFASTINT (w
->last_modified
, 0);
2571 tem
= Fvertical_motion (make_number (ht
), window
);
2572 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2575 Fvertical_motion (make_number (-1), window
);
2583 Fsignal (Qend_of_buffer
, Qnil
);
2587 /* This is the guts of Fscroll_up and Fscroll_down. */
2590 scroll_command (n
, direction
)
2591 register Lisp_Object n
;
2594 register int defalt
;
2595 int count
= specpdl_ptr
- specpdl
;
2597 /* If selected window's buffer isn't current, make it current for the moment.
2598 But don't screw up if window_scroll gets an error. */
2599 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2601 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2602 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2605 defalt
= (window_internal_height (XWINDOW (selected_window
))
2606 - next_screen_context_lines
);
2607 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2610 window_scroll (selected_window
, defalt
, 0);
2611 else if (EQ (n
, Qminus
))
2612 window_scroll (selected_window
, - defalt
, 0);
2615 n
= Fprefix_numeric_value (n
);
2616 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2619 unbind_to (count
, Qnil
);
2622 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2623 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2624 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2625 Negative ARG means scroll downward.\n\
2626 When calling from a program, supply a number as argument or nil.")
2630 scroll_command (n
, 1);
2634 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2635 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2636 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2637 Negative ARG means scroll upward.\n\
2638 When calling from a program, supply a number as argument or nil.")
2642 scroll_command (n
, -1);
2646 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2647 "Return the other window for \"other window scroll\" commands.\n\
2648 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2649 specifies the window.\n\
2650 If `other-window-scroll-buffer' is non-nil, a window\n\
2651 showing that buffer is used.")
2656 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2657 && !NILP (Vminibuf_scroll_window
))
2658 window
= Vminibuf_scroll_window
;
2659 /* If buffer is specified, scroll that buffer. */
2660 else if (!NILP (Vother_window_scroll_buffer
))
2662 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2664 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2668 /* Nothing specified; look for a neighboring window on the same
2670 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2672 if (EQ (window
, selected_window
))
2673 /* That didn't get us anywhere; look for a window on another
2676 window
= Fnext_window (window
, Qnil
, Qt
);
2677 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2678 && ! EQ (window
, selected_window
));
2681 CHECK_LIVE_WINDOW (window
, 0);
2683 if (EQ (window
, selected_window
))
2684 error ("There is no other window");
2689 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2690 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2691 The next window is the one below the current one; or the one at the top\n\
2692 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2693 When calling from a program, supply a number as argument or nil.\n\
2695 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2696 specifies the window to scroll.\n\
2697 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2698 showing that buffer, popping the buffer up if necessary.")
2700 register Lisp_Object n
;
2702 register Lisp_Object window
;
2703 register int defalt
;
2704 register struct window
*w
;
2705 register int count
= specpdl_ptr
- specpdl
;
2707 window
= Fother_window_for_scrolling ();
2709 w
= XWINDOW (window
);
2710 defalt
= window_internal_height (w
) - next_screen_context_lines
;
2711 if (defalt
< 1) defalt
= 1;
2713 /* Don't screw up if window_scroll gets an error. */
2714 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2716 Fset_buffer (w
->buffer
);
2717 SET_PT (marker_position (w
->pointm
));
2720 window_scroll (window
, defalt
, 1);
2721 else if (EQ (n
, Qminus
))
2722 window_scroll (window
, -defalt
, 1);
2727 CHECK_NUMBER (n
, 0);
2728 window_scroll (window
, XINT (n
), 1);
2731 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2732 unbind_to (count
, Qnil
);
2737 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2738 "Scroll selected window display ARG columns left.\n\
2739 Default for ARG is window width minus 2.")
2741 register Lisp_Object arg
;
2745 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2747 arg
= Fprefix_numeric_value (arg
);
2750 Fset_window_hscroll (selected_window
,
2751 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2755 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2756 "Scroll selected window display ARG columns right.\n\
2757 Default for ARG is window width minus 2.")
2759 register Lisp_Object arg
;
2762 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2764 arg
= Fprefix_numeric_value (arg
);
2767 Fset_window_hscroll (selected_window
,
2768 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2772 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2773 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2774 The desired position of point is always relative to the current window.\n\
2775 Just C-u as prefix means put point in the center of the window.\n\
2776 No arg (i.e., it is nil) erases the entire frame and then\n\
2777 redraws with point in the center of the current window.")
2779 register Lisp_Object n
;
2781 register struct window
*w
= XWINDOW (selected_window
);
2782 register int ht
= window_internal_height (w
);
2783 struct position pos
;
2788 extern int frame_garbaged
;
2790 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2791 XSETFASTINT (n
, ht
/ 2);
2793 else if (CONSP (n
)) /* Just C-u. */
2795 XSETFASTINT (n
, ht
/ 2);
2799 n
= Fprefix_numeric_value (n
);
2800 CHECK_NUMBER (n
, 0);
2804 XSETINT (n
, XINT (n
) + ht
);
2806 XSETWINDOW (window
, w
);
2807 pos
= *vmotion (point
, - XINT (n
), window_internal_width (w
) - 1,
2808 XINT (w
->hscroll
), window
);
2810 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
2811 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
2812 || FETCH_CHAR (pos
.bufpos
- 1) == '\n')
2814 w
->force_start
= Qt
;
2819 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2821 "Position point relative to window.\n\
2822 With no argument, position point at center of window.\n\
2823 An argument specifies frame line; zero means top of window,\n\
2824 negative means relative to bottom of window.")
2826 register Lisp_Object arg
;
2828 register struct window
*w
= XWINDOW (selected_window
);
2829 register int height
= window_internal_height (w
);
2834 XSETFASTINT (arg
, height
/ 2);
2837 arg
= Fprefix_numeric_value (arg
);
2839 XSETINT (arg
, XINT (arg
) + height
);
2842 start
= marker_position (w
->start
);
2843 XSETWINDOW (window
, w
);
2844 if (start
< BEGV
|| start
> ZV
)
2846 Fvertical_motion (make_number (- (height
/ 2)), window
);
2847 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2848 w
->start_at_line_beg
= Fbolp ();
2849 w
->force_start
= Qt
;
2854 return Fvertical_motion (arg
, window
);
2857 struct save_window_data
2859 int size_from_Lisp_Vector_struct
;
2860 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2861 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2862 Lisp_Object selected_frame
;
2863 Lisp_Object current_window
;
2864 Lisp_Object current_buffer
;
2865 Lisp_Object minibuf_scroll_window
;
2866 Lisp_Object root_window
;
2867 Lisp_Object focus_frame
;
2868 /* Record the values of window-min-width and window-min-height
2869 so that window sizes remain consistent with them. */
2870 Lisp_Object min_width
, min_height
;
2871 /* A vector, interpreted as a struct saved_window */
2872 Lisp_Object saved_windows
;
2875 /* This is saved as a Lisp_Vector */
2878 /* these first two must agree with struct Lisp_Vector in lisp.h */
2879 int size_from_Lisp_Vector_struct
;
2880 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2883 Lisp_Object buffer
, start
, pointm
, mark
;
2884 Lisp_Object left
, top
, width
, height
, hscroll
;
2885 Lisp_Object parent
, prev
;
2886 Lisp_Object start_at_line_beg
;
2887 Lisp_Object display_table
;
2889 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2891 #define SAVED_WINDOW_N(swv,n) \
2892 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2894 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2895 "T if OBJECT is a window-configration object.")
2899 if (WINDOW_CONFIGURATIONP (obj
))
2905 DEFUN ("set-window-configuration", Fset_window_configuration
,
2906 Sset_window_configuration
, 1, 1, 0,
2907 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2908 CONFIGURATION must be a value previously returned\n\
2909 by `current-window-configuration' (which see).")
2911 Lisp_Object configuration
;
2913 register struct save_window_data
*data
;
2914 struct Lisp_Vector
*saved_windows
;
2915 Lisp_Object new_current_buffer
;
2919 while (!WINDOW_CONFIGURATIONP (configuration
))
2921 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2925 data
= (struct save_window_data
*) XVECTOR (configuration
);
2926 saved_windows
= XVECTOR (data
->saved_windows
);
2928 new_current_buffer
= data
->current_buffer
;
2929 if (NILP (XBUFFER (new_current_buffer
)->name
))
2930 new_current_buffer
= Qnil
;
2932 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2935 /* If f is a dead frame, don't bother rebuilding its window tree.
2936 However, there is other stuff we should still try to do below. */
2937 if (FRAME_LIVE_P (f
))
2939 register struct window
*w
;
2940 register struct saved_window
*p
;
2943 /* If the frame has been resized since this window configuration was
2944 made, we change the frame to the size specified in the
2945 configuration, restore the configuration, and then resize it
2946 back. We keep track of the prevailing height in these variables. */
2947 int previous_frame_height
= FRAME_HEIGHT (f
);
2948 int previous_frame_width
= FRAME_WIDTH (f
);
2949 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2951 if (XFASTINT (data
->frame_height
) != previous_frame_height
2952 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2953 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2954 #ifdef HAVE_X_WINDOWS
2955 if (XFASTINT (data
->frame_menu_bar_lines
)
2956 != previous_frame_menu_bar_lines
)
2957 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2960 windows_or_buffers_changed
++;
2961 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2963 /* Temporarily avoid any problems with windows that are smaller
2964 than they are supposed to be. */
2965 window_min_height
= 1;
2966 window_min_width
= 1;
2969 Mark all windows now on frame as "deleted".
2970 Restoring the new configuration "undeletes" any that are in it.
2972 Save their current buffers in their height fields, since we may
2973 need it later, if a buffer saved in the configuration is now
2975 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2977 for (k
= 0; k
< saved_windows
->size
; k
++)
2979 p
= SAVED_WINDOW_N (saved_windows
, k
);
2980 w
= XWINDOW (p
->window
);
2983 if (!NILP (p
->parent
))
2984 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2985 XFASTINT (p
->parent
))->window
;
2989 if (!NILP (p
->prev
))
2991 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2992 XFASTINT (p
->prev
))->window
;
2993 XWINDOW (w
->prev
)->next
= p
->window
;
2998 if (!NILP (w
->parent
))
3000 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
3002 XWINDOW (w
->parent
)->vchild
= p
->window
;
3003 XWINDOW (w
->parent
)->hchild
= Qnil
;
3007 XWINDOW (w
->parent
)->hchild
= p
->window
;
3008 XWINDOW (w
->parent
)->vchild
= Qnil
;
3013 /* If we squirreled away the buffer in the window's height,
3015 if (BUFFERP (w
->height
))
3016 w
->buffer
= w
->height
;
3019 w
->width
= p
->width
;
3020 w
->height
= p
->height
;
3021 w
->hscroll
= p
->hscroll
;
3022 w
->display_table
= p
->display_table
;
3023 XSETFASTINT (w
->last_modified
, 0);
3025 /* Reinstall the saved buffer and pointers into it. */
3026 if (NILP (p
->buffer
))
3027 w
->buffer
= p
->buffer
;
3030 if (!NILP (XBUFFER (p
->buffer
)->name
))
3031 /* If saved buffer is alive, install it. */
3033 w
->buffer
= p
->buffer
;
3034 w
->start_at_line_beg
= p
->start_at_line_beg
;
3035 set_marker_restricted (w
->start
,
3036 Fmarker_position (p
->start
),
3038 set_marker_restricted (w
->pointm
,
3039 Fmarker_position (p
->pointm
),
3041 Fset_marker (XBUFFER (w
->buffer
)->mark
,
3042 Fmarker_position (p
->mark
), w
->buffer
);
3044 /* As documented in Fcurrent_window_configuration, don't
3045 save the location of point in the buffer which was current
3046 when the window configuration was recorded. */
3047 if (!EQ (p
->buffer
, new_current_buffer
)
3048 && XBUFFER (p
->buffer
) == current_buffer
)
3049 Fgoto_char (w
->pointm
);
3051 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
3052 /* Else unless window has a live buffer, get one. */
3054 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
3055 /* This will set the markers to beginning of visible
3057 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
3058 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
3059 w
->start_at_line_beg
= Qt
;
3062 /* Keeping window's old buffer; make sure the markers
3065 /* Set window markers at start of visible range. */
3066 if (XMARKER (w
->start
)->buffer
== 0)
3067 set_marker_restricted (w
->start
, make_number (0),
3069 if (XMARKER (w
->pointm
)->buffer
== 0)
3070 set_marker_restricted (w
->pointm
,
3072 (BUF_PT (XBUFFER (w
->buffer
)))),
3074 w
->start_at_line_beg
= Qt
;
3079 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
3080 Fselect_window (data
->current_window
);
3083 if (NILP (data
->focus_frame
)
3084 || (FRAMEP (data
->focus_frame
)
3085 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
3086 Fredirect_frame_focus (frame
, data
->focus_frame
);
3089 #if 0 /* I don't understand why this is needed, and it causes problems
3090 when the frame's old selected window has been deleted. */
3092 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
3093 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
3097 /* Set the screen height to the value it had before this function. */
3098 if (previous_frame_height
!= FRAME_HEIGHT (f
)
3099 || previous_frame_width
!= FRAME_WIDTH (f
))
3100 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
3102 #ifdef HAVE_X_WINDOWS
3103 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
3104 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
3108 /* Restore the minimum heights recorded in the configuration. */
3109 window_min_height
= XINT (data
->min_height
);
3110 window_min_width
= XINT (data
->min_width
);
3113 /* Fselect_window will have made f the selected frame, so we
3114 reselect the proper frame here. Fhandle_switch_frame will change the
3115 selected window too, but that doesn't make the call to
3116 Fselect_window above totally superfluous; it still sets f's
3118 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
3119 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
3122 if (!NILP (new_current_buffer
))
3123 Fset_buffer (new_current_buffer
);
3125 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
3129 /* Mark all windows now on frame as deleted
3130 by setting their buffers to nil. */
3133 delete_all_subwindows (w
)
3134 register struct window
*w
;
3136 if (!NILP (w
->next
))
3137 delete_all_subwindows (XWINDOW (w
->next
));
3138 if (!NILP (w
->vchild
))
3139 delete_all_subwindows (XWINDOW (w
->vchild
));
3140 if (!NILP (w
->hchild
))
3141 delete_all_subwindows (XWINDOW (w
->hchild
));
3143 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3145 /* We set all three of these fields to nil, to make sure that we can
3146 distinguish this dead window from any live window. Live leaf
3147 windows will have buffer set, and combination windows will have
3148 vchild or hchild set. */
3155 count_windows (window
)
3156 register struct window
*window
;
3158 register int count
= 1;
3159 if (!NILP (window
->next
))
3160 count
+= count_windows (XWINDOW (window
->next
));
3161 if (!NILP (window
->vchild
))
3162 count
+= count_windows (XWINDOW (window
->vchild
));
3163 if (!NILP (window
->hchild
))
3164 count
+= count_windows (XWINDOW (window
->hchild
));
3169 save_window_save (window
, vector
, i
)
3171 struct Lisp_Vector
*vector
;
3174 register struct saved_window
*p
;
3175 register struct window
*w
;
3176 register Lisp_Object tem
;
3178 for (;!NILP (window
); window
= w
->next
)
3180 p
= SAVED_WINDOW_N (vector
, i
);
3181 w
= XWINDOW (window
);
3183 XSETFASTINT (w
->temslot
, i
++);
3185 p
->buffer
= w
->buffer
;
3188 p
->width
= w
->width
;
3189 p
->height
= w
->height
;
3190 p
->hscroll
= w
->hscroll
;
3191 p
->display_table
= w
->display_table
;
3192 if (!NILP (w
->buffer
))
3194 /* Save w's value of point in the window configuration.
3195 If w is the selected window, then get the value of point
3196 from the buffer; pointm is garbage in the selected window. */
3197 if (EQ (window
, selected_window
))
3199 p
->pointm
= Fmake_marker ();
3200 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
3204 p
->pointm
= Fcopy_marker (w
->pointm
);
3206 p
->start
= Fcopy_marker (w
->start
);
3207 p
->start_at_line_beg
= w
->start_at_line_beg
;
3209 tem
= XBUFFER (w
->buffer
)->mark
;
3210 p
->mark
= Fcopy_marker (tem
);
3217 p
->start_at_line_beg
= Qnil
;
3220 if (NILP (w
->parent
))
3223 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3228 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3230 if (!NILP (w
->vchild
))
3231 i
= save_window_save (w
->vchild
, vector
, i
);
3232 if (!NILP (w
->hchild
))
3233 i
= save_window_save (w
->hchild
, vector
, i
);
3239 DEFUN ("current-window-configuration",
3240 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3241 "Return an object representing the current window configuration of FRAME.\n\
3242 If FRAME is nil or omitted, use the selected frame.\n\
3243 This describes the number of windows, their sizes and current buffers,\n\
3244 and for each displayed buffer, where display starts, and the positions of\n\
3245 point and mark. An exception is made for point in the current buffer:\n\
3246 its value is -not- saved.\n\
3247 This also records the currently selected frame, and FRAME's focus\n\
3248 redirection (see `redirect-frame-focus').")
3252 register Lisp_Object tem
;
3253 register int n_windows
;
3254 register struct save_window_data
*data
;
3255 register struct Lisp_Vector
*vec
;
3263 CHECK_LIVE_FRAME (frame
, 0);
3267 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3268 vec
= allocate_vectorlike (VECSIZE (struct save_window_data
));
3269 for (i
= 0; i
< VECSIZE (struct save_window_data
); i
++)
3270 vec
->contents
[i
] = Qnil
;
3271 vec
->size
= VECSIZE (struct save_window_data
);
3272 data
= (struct save_window_data
*)vec
;
3274 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
3275 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
3276 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
3278 XSETFRAME (data
->selected_frame
, selected_frame
);
3280 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3281 XSETBUFFER (data
->current_buffer
, current_buffer
);
3282 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3283 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3284 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3285 XSETINT (data
->min_height
, window_min_height
);
3286 XSETINT (data
->min_width
, window_min_width
);
3287 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3288 data
->saved_windows
= tem
;
3289 for (i
= 0; i
< n_windows
; i
++)
3290 XVECTOR (tem
)->contents
[i
]
3291 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3292 save_window_save (FRAME_ROOT_WINDOW (f
),
3294 XSETWINDOW_CONFIGURATION (tem
, data
);
3298 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3300 "Execute body, preserving window sizes and contents.\n\
3301 Restore which buffer appears in which window, where display starts,\n\
3302 and the value of point and mark for each window.\n\
3303 Also restore which buffer is current.\n\
3304 But do not preserve point in the current buffer.\n\
3305 Does not restore the value of point in current buffer.")
3309 register Lisp_Object val
;
3310 register int count
= specpdl_ptr
- specpdl
;
3312 record_unwind_protect (Fset_window_configuration
,
3313 Fcurrent_window_configuration (Qnil
));
3314 val
= Fprogn (args
);
3315 return unbind_to (count
, val
);
3321 selected_frame
= make_terminal_frame ();
3322 minibuf_window
= selected_frame
->minibuffer_window
;
3323 selected_window
= selected_frame
->selected_window
;
3324 last_nonminibuf_frame
= selected_frame
;
3325 #else /* not MULTI_FRAME */
3326 extern Lisp_Object
get_minibuffer ();
3328 selected_frame
= last_nonminibuf_frame
= &the_only_frame
;
3330 minibuf_window
= make_window ();
3331 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3333 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3334 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3335 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3337 /* These values 9 and 10 are arbitrary,
3338 just so that there is "something there."
3339 Correct values are put in in init_xdisp */
3341 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
, 10);
3342 XSETFASTINT (XWINDOW (minibuf_window
)->width
, 10);
3344 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
, 9);
3345 XSETFASTINT (XWINDOW (minibuf_window
)->top
, 9);
3346 XSETFASTINT (XWINDOW (minibuf_window
)->height
, 1);
3348 /* Prevent error in Fset_window_buffer. */
3349 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3350 XWINDOW (minibuf_window
)->buffer
= Qt
;
3352 /* Now set them up for real. */
3353 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3354 Fcurrent_buffer ());
3355 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3357 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3358 /* Make sure this window seems more recently used than
3359 a newly-created, never-selected window. Increment
3360 window_select_count so the first selection ever will get
3361 something newer than this. */
3362 XSETFASTINT (XWINDOW (selected_window
)->use_time
, ++window_select_count
);
3363 #endif /* not MULTI_FRAME */
3368 Qwindowp
= intern ("windowp");
3369 staticpro (&Qwindowp
);
3371 Qwindow_live_p
= intern ("window-live-p");
3372 staticpro (&Qwindow_live_p
);
3374 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
3375 staticpro (&Qtemp_buffer_show_hook
);
3378 /* Make sure all windows get marked */
3379 staticpro (&minibuf_window
);
3382 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3383 "Non-nil means call as function to display a help buffer.\n\
3384 The function is called with one argument, the buffer to be displayed.\n\
3385 Used by `with-output-to-temp-buffer'.\n\
3386 If this function is used, then it must do the entire job of showing\n\
3387 the buffer; `temp-buffer-show-hook' is not run unless this function runs it.");
3388 Vtemp_buffer_show_function
= Qnil
;
3390 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3391 "If non-nil, function to call to handle `display-buffer'.\n\
3392 It will receive two args, the buffer and a flag which if non-nil means\n\
3393 that the currently selected window is not acceptable.\n\
3394 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3395 work using this function.");
3396 Vdisplay_buffer_function
= Qnil
;
3398 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3399 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3400 Vminibuf_scroll_window
= Qnil
;
3402 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3403 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3404 Vother_window_scroll_buffer
= Qnil
;
3406 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3407 "*Non-nil means `display-buffer' should make a separate frame.");
3410 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3411 "Function to call to handle automatic new frame creation.\n\
3412 It is called with no arguments and should return a newly created frame.\n\
3414 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3415 where `pop-up-frame-alist' would hold the default frame parameters.");
3416 Vpop_up_frame_function
= Qnil
;
3418 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3419 "*List of buffer names that should have their own special frames.\n\
3420 Displaying a buffer whose name is in this list makes a special frame for it\n\
3421 using `special-display-function'.\n\
3423 An element of the list can be a cons cell instead of just a string.\n\
3424 Then the car should be a buffer name, and the cdr specifies frame\n\
3425 parameters for creating the frame for that buffer.\n\
3426 More precisely, the cdr is passed as the second argument to\n\
3427 the function found in `special-display-function', when making that frame.\n\
3428 See also `special-display-regexps'.");
3429 Vspecial_display_buffer_names
= Qnil
;
3431 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3432 "*List of regexps saying which buffers should have their own special frames.\n\
3433 If a buffer name matches one of these regexps, it gets its own frame.\n\
3434 Displaying a buffer whose name is in this list makes a special frame for it\n\
3435 using `special-display-function'.\n\
3437 An element of the list can be a cons cell instead of just a string.\n\
3438 Then the car should be the regexp, and the cdr specifies frame\n\
3439 parameters for creating the frame for buffers that match.\n\
3440 More precisely, the cdr is passed as the second argument to\n\
3441 the function found in `special-display-function', when making that frame.\n\
3442 See also `special-display-buffer-names'.");
3443 Vspecial_display_regexps
= Qnil
;
3445 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3446 "Function to call to make a new frame for a special buffer.\n\
3447 It is called with two arguments, the buffer and optional buffer specific\n\
3448 data, and should return a window displaying that buffer.\n\
3449 The default value makes a separate frame for the buffer,\n\
3450 using `special-display-frame-alist' to specify the frame parameters.\n\
3452 A buffer is special if its is listed in `special-display-buffer-names'\n\
3453 or matches a regexp in `special-display-regexps'.");
3454 Vspecial_display_function
= Qnil
;
3456 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
3457 "*List of buffer names that should appear in the selected window.\n\
3458 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
3459 switches to it in the selected window, rather than making it appear\n\
3460 in some other window.\n\
3462 An element of the list can be a cons cell instead of just a string.\n\
3463 Then the car must be a string, which specifies the buffer name.\n\
3464 This is for compatibility with `special-display-buffer-names';\n\
3465 the cdr of the cons cell is ignored.\n\
3467 See also `same-window-regexps'.");
3468 Vsame_window_buffer_names
= Qnil
;
3470 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
3471 "*List of regexps saying which buffers should appear in the selected window.\n\
3472 If a buffer name matches one of these regexps, then displaying it\n\
3473 using `display-buffer' or `pop-to-buffer' switches to it\n\
3474 in the selected window, rather than making it appear in some other window.\n\
3476 An element of the list can be a cons cell instead of just a string.\n\
3477 Then the car must be a string, which specifies the buffer name.\n\
3478 This is for compatibility with `special-display-buffer-names';\n\
3479 the cdr of the cons cell is ignored.\n\
3481 See also `same-window-buffer-names'.");
3482 Vsame_window_regexps
= Qnil
;
3484 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3485 "*Non-nil means display-buffer should make new windows.");
3488 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3489 "*Number of lines of continuity when scrolling by screenfuls.");
3490 next_screen_context_lines
= 2;
3492 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3493 "*display-buffer would prefer to split the largest window if this large.\n\
3494 If there is only one window, it is split regardless of this value.");
3495 split_height_threshold
= 500;
3497 DEFVAR_INT ("window-min-height", &window_min_height
,
3498 "*Delete any window less than this tall (including its mode line).");
3499 window_min_height
= 4;
3501 DEFVAR_INT ("window-min-width", &window_min_width
,
3502 "*Delete any window less than this wide.");
3503 window_min_width
= 10;
3505 defsubr (&Sselected_window
);
3506 defsubr (&Sminibuffer_window
);
3507 defsubr (&Swindow_minibuffer_p
);
3508 defsubr (&Swindowp
);
3509 defsubr (&Swindow_live_p
);
3510 defsubr (&Spos_visible_in_window_p
);
3511 defsubr (&Swindow_buffer
);
3512 defsubr (&Swindow_height
);
3513 defsubr (&Swindow_width
);
3514 defsubr (&Swindow_hscroll
);
3515 defsubr (&Sset_window_hscroll
);
3516 defsubr (&Swindow_edges
);
3517 defsubr (&Scoordinates_in_window_p
);
3518 defsubr (&Swindow_at
);
3519 defsubr (&Swindow_point
);
3520 defsubr (&Swindow_start
);
3521 defsubr (&Swindow_end
);
3522 defsubr (&Sset_window_point
);
3523 defsubr (&Sset_window_start
);
3524 defsubr (&Swindow_dedicated_p
);
3525 defsubr (&Sset_window_dedicated_p
);
3526 defsubr (&Swindow_display_table
);
3527 defsubr (&Sset_window_display_table
);
3528 defsubr (&Snext_window
);
3529 defsubr (&Sprevious_window
);
3530 defsubr (&Sother_window
);
3531 defsubr (&Sget_lru_window
);
3532 defsubr (&Sget_largest_window
);
3533 defsubr (&Sget_buffer_window
);
3534 defsubr (&Sdelete_other_windows
);
3535 defsubr (&Sdelete_windows_on
);
3536 defsubr (&Sreplace_buffer_in_windows
);
3537 defsubr (&Sdelete_window
);
3538 defsubr (&Sset_window_buffer
);
3539 defsubr (&Sselect_window
);
3540 defsubr (&Sdisplay_buffer
);
3541 defsubr (&Ssplit_window
);
3542 defsubr (&Senlarge_window
);
3543 defsubr (&Sshrink_window
);
3544 defsubr (&Sscroll_up
);
3545 defsubr (&Sscroll_down
);
3546 defsubr (&Sscroll_left
);
3547 defsubr (&Sscroll_right
);
3548 defsubr (&Sother_window_for_scrolling
);
3549 defsubr (&Sscroll_other_window
);
3550 defsubr (&Srecenter
);
3551 defsubr (&Smove_to_window_line
);
3552 defsubr (&Swindow_configuration_p
);
3553 defsubr (&Sset_window_configuration
);
3554 defsubr (&Scurrent_window_configuration
);
3555 defsubr (&Ssave_window_excursion
);
3560 initial_define_key (control_x_map
, '1', "delete-other-windows");
3561 initial_define_key (control_x_map
, '2', "split-window");
3562 initial_define_key (control_x_map
, '0', "delete-window");
3563 initial_define_key (control_x_map
, 'o', "other-window");
3564 initial_define_key (control_x_map
, '^', "enlarge-window");
3565 initial_define_key (control_x_map
, '<', "scroll-left");
3566 initial_define_key (control_x_map
, '>', "scroll-right");
3568 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3569 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3570 initial_define_key (meta_map
, 'v', "scroll-down");
3572 initial_define_key (global_map
, Ctl('L'), "recenter");
3573 initial_define_key (meta_map
, 'r', "move-to-window-line");