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 Anything else means restrict to WINDOW's frame.\n\
893 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
894 `next-window' to iterate through the entire cycle of acceptable\n\
895 windows, eventually ending up back at the window you started with.\n\
896 `previous-window' traverses the same cycle, in the reverse order.")
897 (window, minibuf, all_frames) */
899 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
901 (window
, minibuf
, all_frames
)
902 register Lisp_Object window
, minibuf
, all_frames
;
904 register Lisp_Object tem
;
905 Lisp_Object start_window
;
908 window
= selected_window
;
910 CHECK_LIVE_WINDOW (window
, 0);
912 start_window
= window
;
914 /* minibuf == nil may or may not include minibuffers.
915 Decide if it does. */
917 minibuf
= (minibuf_level
? Qt
: Qlambda
);
920 /* all_frames == nil doesn't specify which frames to include. */
921 if (NILP (all_frames
))
922 all_frames
= (EQ (minibuf
, Qt
)
923 ? (FRAME_MINIBUF_WINDOW
926 (XWINDOW (window
)))))
928 else if (EQ (all_frames
, Qvisible
))
930 else if (XFASTINT (all_frames
) == 0)
932 else if (! EQ (all_frames
, Qt
))
934 /* Now all_frames is t meaning search all frames,
935 nil meaning search just current frame,
936 visible meaning search just visible frames,
937 0 meaning search visible and iconified frames,
938 or a window, meaning search the frame that window belongs to. */
941 /* Do this loop at least once, to get the next window, and perhaps
942 again, if we hit the minibuffer and that is not acceptable. */
945 /* Find a window that actually has a next one. This loop
946 climbs up the tree. */
947 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
948 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
952 /* We've reached the end of this frame.
953 Which other frames are acceptable? */
954 tem
= WINDOW_FRAME (XWINDOW (window
));
956 if (! NILP (all_frames
))
961 tem
= next_frame (tem
, all_frames
);
962 /* In the case where the minibuffer is active,
963 and we include its frame as well as the selected one,
964 next_frame may get stuck in that frame.
965 If that happens, go back to the selected frame
966 so we can complete the cycle. */
968 XSETFRAME (tem
, selected_frame
);
971 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
978 /* If we're in a combination window, find its first child and
979 recurse on that. Otherwise, we've found the window we want. */
982 if (!NILP (XWINDOW (window
)->hchild
))
983 window
= XWINDOW (window
)->hchild
;
984 else if (!NILP (XWINDOW (window
)->vchild
))
985 window
= XWINDOW (window
)->vchild
;
989 /* Which windows are acceptible?
990 Exit the loop and accept this window if
991 this isn't a minibuffer window, or
992 we're accepting minibuffer windows, or
993 we've come all the way around and we're back at the original window. */
994 while (MINI_WINDOW_P (XWINDOW (window
))
995 && ! EQ (minibuf
, Qt
)
996 && ! EQ (window
, start_window
));
1001 /* This comment supplies the doc string for `previous-window',
1002 for make-docfile to see. We cannot put this in the real DEFUN
1003 due to limits in the Unix cpp.
1005 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
1006 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
1007 If omitted, WINDOW defaults to the selected window.\n\
1009 Optional second arg MINIBUF t means count the minibuffer window even\n\
1010 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1011 it is active. MINIBUF neither t nor nil means not to count the\n\
1012 minibuffer even if it is active.\n\
1014 Several frames may share a single minibuffer; if the minibuffer\n\
1015 counts, all windows on all frames that share that minibuffer count\n\
1016 too. Therefore, `previous-window' can be used to iterate through\n\
1017 the set of windows even when the minibuffer is on another frame. If\n\
1018 the minibuffer does not count, only windows from WINDOW's frame count\n\
1020 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1021 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1022 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1023 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1024 Anything else means restrict to WINDOW's frame.\n\
1026 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1027 `previous-window' to iterate through the entire cycle of acceptable\n\
1028 windows, eventually ending up back at the window you started with.\n\
1029 `next-window' traverses the same cycle, in the reverse order.")
1030 (window, minibuf, all_frames) */
1033 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1035 (window
, minibuf
, all_frames
)
1036 register Lisp_Object window
, minibuf
, all_frames
;
1038 register Lisp_Object tem
;
1039 Lisp_Object start_window
;
1042 window
= selected_window
;
1044 CHECK_LIVE_WINDOW (window
, 0);
1046 start_window
= window
;
1048 /* minibuf == nil may or may not include minibuffers.
1049 Decide if it does. */
1051 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1054 /* all_frames == nil doesn't specify which frames to include.
1055 Decide which frames it includes. */
1056 if (NILP (all_frames
))
1057 all_frames
= (EQ (minibuf
, Qt
)
1058 ? (FRAME_MINIBUF_WINDOW
1061 (XWINDOW (window
)))))
1063 else if (EQ (all_frames
, Qvisible
))
1065 else if (XFASTINT (all_frames
) == 0)
1067 else if (! EQ (all_frames
, Qt
))
1069 /* Now all_frames is t meaning search all frames,
1070 nil meaning search just current frame,
1071 visible meaning search just visible frames,
1072 0 meaning search visible and iconified frames,
1073 or a window, meaning search the frame that window belongs to. */
1076 /* Do this loop at least once, to get the previous window, and perhaps
1077 again, if we hit the minibuffer and that is not acceptable. */
1080 /* Find a window that actually has a previous one. This loop
1081 climbs up the tree. */
1082 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1083 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1087 /* We have found the top window on the frame.
1088 Which frames are acceptable? */
1089 tem
= WINDOW_FRAME (XWINDOW (window
));
1091 if (! NILP (all_frames
))
1092 /* It's actually important that we use prev_frame here,
1093 rather than next_frame. All the windows acceptable
1094 according to the given parameters should form a ring;
1095 Fnext_window and Fprevious_window should go back and
1096 forth around the ring. If we use next_frame here,
1097 then Fnext_window and Fprevious_window take different
1098 paths through the set of acceptable windows.
1099 window_loop assumes that these `ring' requirement are
1105 tem
= prev_frame (tem
, all_frames
);
1106 /* In the case where the minibuffer is active,
1107 and we include its frame as well as the selected one,
1108 next_frame may get stuck in that frame.
1109 If that happens, go back to the selected frame
1110 so we can complete the cycle. */
1112 XSETFRAME (tem
, selected_frame
);
1115 /* If this frame has a minibuffer, find that window first,
1116 because it is conceptually the last window in that frame. */
1117 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1118 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1120 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1126 /* If we're in a combination window, find its last child and
1127 recurse on that. Otherwise, we've found the window we want. */
1130 if (!NILP (XWINDOW (window
)->hchild
))
1131 window
= XWINDOW (window
)->hchild
;
1132 else if (!NILP (XWINDOW (window
)->vchild
))
1133 window
= XWINDOW (window
)->vchild
;
1135 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1139 /* Which windows are acceptable?
1140 Exit the loop and accept this window if
1141 this isn't a minibuffer window, or
1142 we're accepting minibuffer windows, or
1143 we've come all the way around and we're back at the original window. */
1144 while (MINI_WINDOW_P (XWINDOW (window
))
1145 && !EQ (minibuf
, Qt
)
1146 && !EQ (window
, start_window
));
1151 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1152 "Select the ARG'th different window on this frame.\n\
1153 All windows on current frame are arranged in a cyclic order.\n\
1154 This command selects the window ARG steps away in that order.\n\
1155 A negative ARG moves in the opposite order. If the optional second\n\
1156 argument ALL_FRAMES is non-nil, cycle through all frames.")
1158 register Lisp_Object n
, all_frames
;
1161 register Lisp_Object w
;
1163 CHECK_NUMBER (n
, 0);
1164 w
= selected_window
;
1169 w
= Fnext_window (w
, Qnil
, all_frames
);
1174 w
= Fprevious_window (w
, Qnil
, all_frames
);
1181 /* Look at all windows, performing an operation specified by TYPE
1183 If FRAMES is Qt, look at all frames;
1184 Qnil, look at just the selected frame;
1185 Qvisible, look at visible frames;
1186 a frame, just look at windows on that frame.
1187 If MINI is non-zero, perform the operation on minibuffer windows too.
1193 GET_BUFFER_WINDOW
, /* Arg is buffer */
1194 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1195 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1196 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1198 UNSHOW_BUFFER
/* Arg is buffer */
1202 window_loop (type
, obj
, mini
, frames
)
1203 enum window_loop type
;
1204 register Lisp_Object obj
, frames
;
1207 register Lisp_Object w
;
1208 register Lisp_Object best_window
;
1209 register Lisp_Object next_window
;
1210 register Lisp_Object last_window
;
1212 Lisp_Object frame_arg
;
1216 /* If we're only looping through windows on a particular frame,
1217 frame points to that frame. If we're looping through windows
1218 on all frames, frame is 0. */
1219 if (FRAMEP (frames
))
1220 frame
= XFRAME (frames
);
1221 else if (NILP (frames
))
1222 frame
= selected_frame
;
1226 frame_arg
= Qlambda
;
1227 else if (XFASTINT (frames
) == 0)
1229 else if (EQ (frames
, Qvisible
))
1235 /* frame_arg is Qlambda to stick to one frame,
1236 Qvisible to consider all visible frames,
1239 /* Pick a window to start with. */
1243 w
= FRAME_SELECTED_WINDOW (frame
);
1245 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1247 /* Figure out the last window we're going to mess with. Since
1248 Fnext_window, given the same options, is guaranteed to go in a
1249 ring, we can just use Fprevious_window to find the last one.
1251 We can't just wait until we hit the first window again, because
1252 it might be deleted. */
1254 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1259 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1261 /* Pick the next window now, since some operations will delete
1262 the current window. */
1263 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1265 /* Note that we do not pay attention here to whether
1266 the frame is visible, since Fnext_window skips non-visible frames
1267 if that is desired, under the control of frame_arg. */
1268 if (! MINI_WINDOW_P (XWINDOW (w
))
1269 || (mini
&& minibuf_level
> 0))
1272 case GET_BUFFER_WINDOW
:
1273 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1277 case GET_LRU_WINDOW
:
1278 /* t as arg means consider only full-width windows */
1279 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1280 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1282 /* Ignore dedicated windows and minibuffers. */
1283 if (MINI_WINDOW_P (XWINDOW (w
))
1284 || !NILP (XWINDOW (w
)->dedicated
))
1286 if (NILP (best_window
)
1287 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1288 > XFASTINT (XWINDOW (w
)->use_time
)))
1292 case DELETE_OTHER_WINDOWS
:
1293 if (XWINDOW (w
) != XWINDOW (obj
))
1297 case DELETE_BUFFER_WINDOWS
:
1298 if (EQ (XWINDOW (w
)->buffer
, obj
))
1301 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1303 /* If this window is dedicated, and in a frame of its own,
1305 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1306 && !NILP (XWINDOW (w
)->dedicated
)
1307 && other_visible_frames (f
))
1309 /* Skip the other windows on this frame.
1310 There might be one, the minibuffer! */
1311 if (! EQ (w
, last_window
))
1312 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1314 /* As we go, check for the end of the loop.
1315 We mustn't start going around a second time. */
1316 if (EQ (next_window
, last_window
))
1321 next_window
= Fnext_window (next_window
,
1325 /* Now we can safely delete the frame. */
1326 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1330 /* If we're deleting the buffer displayed in the only window
1331 on the frame, find a new buffer to display there. */
1332 if (NILP (XWINDOW (w
)->parent
))
1334 Lisp_Object new_buffer
;
1335 new_buffer
= Fother_buffer (obj
, Qnil
);
1336 if (NILP (new_buffer
))
1338 = Fget_buffer_create (build_string ("*scratch*"));
1339 Fset_window_buffer (w
, new_buffer
);
1340 if (EQ (w
, selected_window
))
1341 Fset_buffer (XWINDOW (w
)->buffer
);
1348 case GET_LARGEST_WINDOW
:
1349 /* Ignore dedicated windows and minibuffers. */
1350 if (MINI_WINDOW_P (XWINDOW (w
))
1351 || !NILP (XWINDOW (w
)->dedicated
))
1354 struct window
*best_window_ptr
= XWINDOW (best_window
);
1355 struct window
*w_ptr
= XWINDOW (w
);
1356 if (NILP (best_window
)
1357 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1358 > (XFASTINT (best_window_ptr
->height
)
1359 * XFASTINT (best_window_ptr
->width
))))
1365 if (EQ (XWINDOW (w
)->buffer
, obj
))
1367 /* Find another buffer to show in this window. */
1368 Lisp_Object another_buffer
;
1369 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1370 another_buffer
= Fother_buffer (obj
, Qnil
);
1371 if (NILP (another_buffer
))
1373 = Fget_buffer_create (build_string ("*scratch*"));
1375 /* If this window is dedicated, and in a frame of its own,
1377 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1378 && !NILP (XWINDOW (w
)->dedicated
)
1379 && other_visible_frames (f
))
1381 /* Skip the other windows on this frame.
1382 There might be one, the minibuffer! */
1383 if (! EQ (w
, last_window
))
1384 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1386 /* As we go, check for the end of the loop.
1387 We mustn't start going around a second time. */
1388 if (EQ (next_window
, last_window
))
1393 next_window
= Fnext_window (next_window
,
1397 /* Now we can safely delete the frame. */
1398 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1403 /* Otherwise show a different buffer in the window. */
1404 XWINDOW (w
)->dedicated
= Qnil
;
1405 Fset_window_buffer (w
, another_buffer
);
1406 if (EQ (w
, selected_window
))
1407 Fset_buffer (XWINDOW (w
)->buffer
);
1413 if (EQ (w
, last_window
))
1422 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1423 "Return the window least recently selected or used for display.\n\
1424 If optional argument FRAME is `visible', search all visible frames.\n\
1425 If FRAME is 0, search all visible and iconified frames.\n\
1426 If FRAME is t, search all frames.\n\
1427 If FRAME is nil, search only the selected frame.\n\
1428 If FRAME is a frame, search only that frame.")
1432 register Lisp_Object w
;
1433 /* First try for a window that is full-width */
1434 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1435 if (!NILP (w
) && !EQ (w
, selected_window
))
1437 /* If none of them, try the rest */
1438 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1441 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1442 "Return the largest window in area.\n\
1443 If optional argument FRAME is `visible', search all visible frames.\n\
1444 If FRAME is 0, search all visible and iconified frames.\n\
1445 If FRAME is t, search all frames.\n\
1446 If FRAME is nil, search only the selected frame.\n\
1447 If FRAME is a frame, search only that frame.")
1451 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1455 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1456 "Return a window currently displaying BUFFER, or nil if none.\n\
1457 If optional argument FRAME is `visible', search all visible frames.\n\
1458 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1459 If FRAME is t, search all frames.\n\
1460 If FRAME is nil, search only the selected frame.\n\
1461 If FRAME is a frame, search only that frame.")
1463 Lisp_Object buffer
, frame
;
1465 buffer
= Fget_buffer (buffer
);
1466 if (BUFFERP (buffer
))
1467 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1472 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1474 "Make WINDOW (or the selected window) fill its frame.\n\
1475 Only the frame WINDOW is on is affected.\n\
1476 This function tries to reduce display jumps\n\
1477 by keeping the text previously visible in WINDOW\n\
1478 in the same place on the frame. Doing this depends on\n\
1479 the value of (window-start WINDOW), so if calling this function\n\
1480 in a program gives strange scrolling, make sure the window-start\n\
1481 value is reasonable when this function is called.")
1490 window
= selected_window
;
1492 CHECK_LIVE_WINDOW (window
, 0);
1494 w
= XWINDOW (window
);
1496 startpos
= marker_position (w
->start
);
1497 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1499 if (MINI_WINDOW_P (w
) && top
> 0)
1500 error ("Can't expand minibuffer to full frame");
1502 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1504 /* Try to minimize scrolling, by setting the window start to the point
1505 will cause the text at the old window start to be at the same place
1506 on the frame. But don't try to do this if the window start is
1507 outside the visible portion (as might happen when the display is
1508 not current, due to typeahead). */
1509 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1510 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1512 struct position pos
;
1513 struct buffer
*obuf
= current_buffer
;
1515 Fset_buffer (w
->buffer
);
1516 /* This computation used to temporarily move point, but that can
1517 have unwanted side effects due to text properties. */
1518 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1519 XINT (w
->hscroll
), window
);
1520 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1521 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1522 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1525 set_buffer_internal (obuf
);
1530 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1531 1, 2, "bDelete windows on (buffer): ",
1532 "Delete all windows showing BUFFER.\n\
1533 Optional second argument FRAME controls which frames are affected.\n\
1534 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1535 If t, delete only windows showing BUFFER in the selected frame.\n\
1536 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1537 If a frame, delete only windows showing BUFFER in that frame.")
1539 Lisp_Object buffer
, frame
;
1542 /* FRAME uses t and nil to mean the opposite of what window_loop
1544 if (! FRAMEP (frame
))
1545 frame
= NILP (frame
) ? Qt
: Qnil
;
1552 buffer
= Fget_buffer (buffer
);
1553 CHECK_BUFFER (buffer
, 0);
1554 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1559 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1560 Sreplace_buffer_in_windows
,
1561 1, 1, "bReplace buffer in windows: ",
1562 "Replace BUFFER with some other buffer in all windows showing it.")
1568 buffer
= Fget_buffer (buffer
);
1569 CHECK_BUFFER (buffer
, 0);
1570 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1575 /* Set the height of WINDOW and all its inferiors. */
1577 /* The smallest acceptable dimensions for a window. Anything smaller
1578 might crash Emacs. */
1579 #define MIN_SAFE_WINDOW_WIDTH (2)
1580 #define MIN_SAFE_WINDOW_HEIGHT (2)
1582 /* Make sure that window_min_height and window_min_width are
1583 not too small; if they are, set them to safe minima. */
1586 check_min_window_sizes ()
1588 /* Smaller values might permit a crash. */
1589 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1590 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1591 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1592 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1595 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1596 minimum allowable size. */
1598 check_frame_size (frame
, rows
, cols
)
1602 /* For height, we have to see:
1603 whether the frame has a minibuffer,
1604 whether it wants a mode line, and
1605 whether it has a menu bar. */
1607 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1608 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1609 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1610 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1611 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1613 if (*rows
< min_height
)
1615 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1616 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1619 /* Normally the window is deleted if it gets too small.
1620 nodelete nonzero means do not do this.
1621 (The caller should check later and do so if appropriate) */
1623 set_window_height (window
, height
, nodelete
)
1628 register struct window
*w
= XWINDOW (window
);
1629 register struct window
*c
;
1630 int oheight
= XFASTINT (w
->height
);
1631 int top
, pos
, lastbot
, opos
, lastobot
;
1634 check_min_window_sizes ();
1637 && ! NILP (w
->parent
)
1638 && height
< window_min_height
)
1640 Fdelete_window (window
);
1644 XSETFASTINT (w
->last_modified
, 0);
1645 windows_or_buffers_changed
++;
1646 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1648 XSETFASTINT (w
->height
, height
);
1649 if (!NILP (w
->hchild
))
1651 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1653 XWINDOW (child
)->top
= w
->top
;
1654 set_window_height (child
, height
, nodelete
);
1657 else if (!NILP (w
->vchild
))
1659 lastbot
= top
= XFASTINT (w
->top
);
1661 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1663 c
= XWINDOW (child
);
1665 opos
= lastobot
+ XFASTINT (c
->height
);
1667 XSETFASTINT (c
->top
, lastbot
);
1669 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1671 /* Avoid confusion: inhibit deletion of child if becomes too small */
1672 set_window_height (child
, pos
+ top
- lastbot
, 1);
1674 /* Now advance child to next window,
1675 and set lastbot if child was not just deleted. */
1676 lastbot
= pos
+ top
;
1679 /* Now delete any children that became too small. */
1681 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1683 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1688 /* Recursively set width of WINDOW and its inferiors. */
1690 set_window_width (window
, width
, nodelete
)
1695 register struct window
*w
= XWINDOW (window
);
1696 register struct window
*c
;
1697 int owidth
= XFASTINT (w
->width
);
1698 int left
, pos
, lastright
, opos
, lastoright
;
1701 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1703 Fdelete_window (window
);
1707 XSETFASTINT (w
->last_modified
, 0);
1708 windows_or_buffers_changed
++;
1709 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1711 XSETFASTINT (w
->width
, width
);
1712 if (!NILP (w
->vchild
))
1714 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1716 XWINDOW (child
)->left
= w
->left
;
1717 set_window_width (child
, width
, nodelete
);
1720 else if (!NILP (w
->hchild
))
1722 lastright
= left
= XFASTINT (w
->left
);
1724 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1726 c
= XWINDOW (child
);
1728 opos
= lastoright
+ XFASTINT (c
->width
);
1730 XSETFASTINT (c
->left
, lastright
);
1732 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1734 /* Inhibit deletion for becoming too small */
1735 set_window_width (child
, pos
+ left
- lastright
, 1);
1737 /* Now advance child to next window,
1738 and set lastright if child was not just deleted. */
1739 lastright
= pos
+ left
, lastoright
= opos
;
1741 /* Delete children that became too small */
1743 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1745 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1750 int window_select_count
;
1752 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1753 "Make WINDOW display BUFFER as its contents.\n\
1754 BUFFER can be a buffer or buffer name.")
1756 register Lisp_Object window
, buffer
;
1758 register Lisp_Object tem
;
1759 register struct window
*w
= decode_window (window
);
1761 buffer
= Fget_buffer (buffer
);
1762 CHECK_BUFFER (buffer
, 1);
1764 if (NILP (XBUFFER (buffer
)->name
))
1765 error ("Attempt to display deleted buffer");
1769 error ("Window is deleted");
1770 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1771 is first being set up. */
1773 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1774 error ("Window is dedicated to `%s'",
1775 XSTRING (XBUFFER (tem
)->name
)->data
);
1781 XSETFASTINT (w
->window_end_pos
, 0);
1782 w
->window_end_valid
= Qnil
;
1783 XSETFASTINT(w
->hscroll
, 0);
1784 Fset_marker (w
->pointm
,
1785 make_number (BUF_PT (XBUFFER (buffer
))),
1787 set_marker_restricted (w
->start
,
1788 make_number (XBUFFER (buffer
)->last_window_start
),
1790 w
->start_at_line_beg
= Qnil
;
1791 w
->force_start
= Qnil
;
1792 XSETFASTINT (w
->last_modified
, 0);
1793 windows_or_buffers_changed
++;
1794 if (EQ (window
, selected_window
))
1795 Fset_buffer (buffer
);
1800 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1801 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1802 The main editor command loop selects the buffer of the selected window\n\
1803 before each command.")
1805 register Lisp_Object window
;
1807 register struct window
*w
;
1808 register struct window
*ow
= XWINDOW (selected_window
);
1810 CHECK_LIVE_WINDOW (window
, 0);
1812 w
= XWINDOW (window
);
1814 if (NILP (w
->buffer
))
1815 error ("Trying to select deleted window or non-leaf window");
1817 XSETFASTINT (w
->use_time
, ++window_select_count
);
1818 if (EQ (window
, selected_window
))
1821 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1824 selected_window
= window
;
1826 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1828 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1829 /* Use this rather than Fhandle_switch_frame
1830 so that FRAME_FOCUS_FRAME is moved appropriately as we
1831 move around in the state where a minibuffer in a separate
1833 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1836 selected_frame
->selected_window
= window
;
1839 record_buffer (w
->buffer
);
1840 Fset_buffer (w
->buffer
);
1842 /* Go to the point recorded in the window.
1843 This is important when the buffer is in more
1844 than one window. It also matters when
1845 redisplay_window has altered point after scrolling,
1846 because it makes the change only in the window. */
1848 register int new_point
= marker_position (w
->pointm
);
1849 if (new_point
< BEGV
)
1851 else if (new_point
> ZV
)
1857 windows_or_buffers_changed
++;
1861 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1862 "bDisplay buffer: \nP",
1863 "Make BUFFER appear in some window but don't select it.\n\
1864 BUFFER can be a buffer or a buffer name.\n\
1865 If BUFFER is shown already in some window, just use that one,\n\
1866 unless the window is the selected window and the optional second\n\
1867 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1868 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1869 Returns the window displaying BUFFER.")
1870 (buffer
, not_this_window
)
1871 register Lisp_Object buffer
, not_this_window
;
1873 register Lisp_Object window
, tem
;
1875 buffer
= Fget_buffer (buffer
);
1876 CHECK_BUFFER (buffer
, 0);
1878 if (!NILP (Vdisplay_buffer_function
))
1879 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1881 if (NILP (not_this_window
)
1882 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1883 return selected_window
;
1885 /* See if the user has specified this buffer should appear
1886 in the selected window. */
1887 if (NILP (not_this_window
))
1889 tem
= Fmember (XBUFFER (buffer
)->name
, Vsame_window_buffer_names
);
1892 Fswitch_to_buffer (buffer
, Qnil
);
1893 return selected_window
;
1896 tem
= Fassoc (XBUFFER (buffer
)->name
, Vsame_window_buffer_names
);
1899 Fswitch_to_buffer (buffer
, Qnil
);
1900 return selected_window
;
1903 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1905 Lisp_Object car
= XCONS (tem
)->car
;
1907 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1909 Fswitch_to_buffer (buffer
, Qnil
);
1910 return selected_window
;
1912 else if (CONSP (car
)
1913 && STRINGP (XCONS (car
)->car
)
1914 && fast_string_match (XCONS (car
)->car
,
1915 XBUFFER (buffer
)->name
) >= 0)
1917 Fswitch_to_buffer (buffer
, Qnil
);
1918 return selected_window
;
1924 /* If pop_up_frames,
1925 look for a window showing BUFFER on any visible or iconified frame. */
1926 window
= Fget_buffer_window (buffer
, pop_up_frames
? make_number (0) : Qnil
);
1928 window
= Fget_buffer_window (buffer
, Qnil
);
1931 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1934 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1935 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1940 /* Certain buffer names get special handling. */
1941 if (! NILP (Vspecial_display_function
))
1943 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1945 return call1 (Vspecial_display_function
, buffer
);
1947 tem
= Fassoc (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1949 return call2 (Vspecial_display_function
, buffer
, XCONS (tem
)->cdr
);
1951 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1953 Lisp_Object car
= XCONS (tem
)->car
;
1955 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1956 return call1 (Vspecial_display_function
, buffer
);
1957 else if (CONSP (car
)
1958 && STRINGP (XCONS (car
)->car
)
1959 && fast_string_match (XCONS (car
)->car
,
1960 XBUFFER (buffer
)->name
) >= 0)
1961 return call2 (Vspecial_display_function
,
1968 /* If there are no frames open that have more than a minibuffer,
1969 we need to create a new frame. */
1970 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1972 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1973 Fset_window_buffer (window
, buffer
);
1976 #endif /* MULTI_FRAME */
1980 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1981 /* If the current frame is a special display frame,
1982 don't try to reuse its windows. */
1983 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
1991 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1992 XSETFRAME (frames
, last_nonminibuf_frame
);
1994 /* Don't try to create a window if would get an error */
1995 if (split_height_threshold
< window_min_height
<< 1)
1996 split_height_threshold
= window_min_height
<< 1;
1998 /* Note that both Fget_largest_window and Fget_lru_window
1999 ignore minibuffers and dedicated windows.
2000 This means they can return nil. */
2003 /* If the frame we would try to split cannot be split,
2004 try other frames. */
2005 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
2006 : last_nonminibuf_frame
))
2008 /* Try visible frames first. */
2009 window
= Fget_largest_window (Qvisible
);
2010 /* If that didn't work, try iconified frames. */
2012 window
= Fget_largest_window (make_number (0));
2014 window
= Fget_largest_window (Qt
);
2018 window
= Fget_largest_window (frames
);
2020 /* If we got a tall enough full-width window that can be split,
2023 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2024 && window_height (window
) >= split_height_threshold
2025 && (XFASTINT (XWINDOW (window
)->width
)
2026 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
2027 window
= Fsplit_window (window
, Qnil
, Qnil
);
2030 Lisp_Object upper
, lower
, other
;
2032 window
= Fget_lru_window (frames
);
2033 /* If the LRU window is selected, and big enough,
2034 and can be split, split it. */
2036 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2037 && (EQ (window
, selected_window
)
2038 || EQ (XWINDOW (window
)->parent
, Qnil
))
2039 && window_height (window
) >= window_min_height
<< 1)
2040 window
= Fsplit_window (window
, Qnil
, Qnil
);
2042 /* If Fget_lru_window returned nil, try other approaches. */
2043 /* Try visible frames first. */
2045 window
= Fget_largest_window (Qvisible
);
2046 /* If that didn't work, try iconified frames. */
2048 window
= Fget_largest_window (make_number (0));
2049 /* Try invisible frames. */
2051 window
= Fget_largest_window (Qt
);
2052 /* As a last resort, make a new frame. */
2054 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2056 /* As a last resort, use a non minibuffer window. */
2058 window
= Fframe_first_window (Fselected_frame ());
2060 /* If window appears above or below another,
2061 even out their heights. */
2062 if (!NILP (XWINDOW (window
)->prev
))
2063 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
2064 if (!NILP (XWINDOW (window
)->next
))
2065 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
2067 /* Check that OTHER and WINDOW are vertically arrayed. */
2068 && XWINDOW (other
)->top
!= XWINDOW (window
)->top
2069 && XWINDOW (other
)->height
> XWINDOW (window
)->height
)
2071 int total
= XWINDOW (other
)->height
+ XWINDOW (window
)->height
;
2072 Lisp_Object old_selected_window
;
2073 old_selected_window
= selected_window
;
2075 selected_window
= upper
;
2076 change_window_height (total
/ 2 - XWINDOW (upper
)->height
, 0);
2077 selected_window
= old_selected_window
;
2082 window
= Fget_lru_window (Qnil
);
2084 Fset_window_buffer (window
, buffer
);
2089 temp_output_buffer_show (buf
)
2090 register Lisp_Object buf
;
2092 register struct buffer
*old
= current_buffer
;
2093 register Lisp_Object window
;
2094 register struct window
*w
;
2097 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
2102 set_buffer_internal (old
);
2104 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
2105 call1 (Vtemp_buffer_show_function
, buf
);
2108 window
= Fdisplay_buffer (buf
, Qnil
);
2111 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2112 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2113 #endif /* MULTI_FRAME */
2114 Vminibuf_scroll_window
= window
;
2115 w
= XWINDOW (window
);
2116 XSETFASTINT (w
->hscroll
, 0);
2117 set_marker_restricted (w
->start
, make_number (1), buf
);
2118 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2121 if (!NILP (Vrun_hooks
))
2122 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
2126 make_dummy_parent (window
)
2130 register struct window
*o
, *p
;
2131 register struct Lisp_Vector
*vec
;
2134 o
= XWINDOW (window
);
2135 vec
= allocate_vectorlike ((EMACS_INT
)VECSIZE (struct window
));
2136 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
2137 vec
->contents
[i
] = ((struct Lisp_Vector
*)o
)->contents
[i
];
2138 vec
->size
= VECSIZE (struct window
);
2139 p
= (struct window
*)vec
;
2140 XSETWINDOW (new, p
);
2142 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
2144 /* Put new into window structure in place of window */
2145 replace_window (window
, new);
2158 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2159 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2160 WINDOW defaults to selected one and SIZE to half its size.\n\
2161 If optional third arg HOR-FLAG is non-nil, split side by side\n\
2162 and put SIZE columns in the first of the pair.")
2163 (window
, chsize
, horflag
)
2164 Lisp_Object window
, chsize
, horflag
;
2166 register Lisp_Object
new;
2167 register struct window
*o
, *p
;
2171 window
= selected_window
;
2173 CHECK_LIVE_WINDOW (window
, 0);
2175 o
= XWINDOW (window
);
2179 if (!NILP (horflag
))
2180 /* Round odd size up, since this is for the left-hand window,
2181 and it will lose a column for the separators. */
2182 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
2184 size
= XFASTINT (o
->height
) >> 1;
2188 CHECK_NUMBER (chsize
, 1);
2189 size
= XINT (chsize
);
2192 if (MINI_WINDOW_P (o
))
2193 error ("Attempt to split minibuffer window");
2194 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
2195 error ("Attempt to split unsplittable frame");
2197 check_min_window_sizes ();
2201 if (size
< window_min_height
2202 || size
+ window_min_height
> XFASTINT (o
->height
))
2203 args_out_of_range_3 (window
, chsize
, horflag
);
2204 if (NILP (o
->parent
)
2205 || NILP (XWINDOW (o
->parent
)->vchild
))
2207 make_dummy_parent (window
);
2209 XWINDOW (new)->vchild
= window
;
2214 if (size
< window_min_width
2215 || size
+ window_min_width
> XFASTINT (o
->width
))
2216 args_out_of_range_3 (window
, chsize
, horflag
);
2217 if (NILP (o
->parent
)
2218 || NILP (XWINDOW (o
->parent
)->hchild
))
2220 make_dummy_parent (window
);
2222 XWINDOW (new)->hchild
= window
;
2226 /* Now we know that window's parent is a vertical combination
2227 if we are dividing vertically, or a horizontal combination
2228 if we are making side-by-side windows */
2230 windows_or_buffers_changed
++;
2231 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (o
))) = 1;
2232 new = make_window ();
2235 p
->frame
= o
->frame
;
2237 if (!NILP (p
->next
))
2238 XWINDOW (p
->next
)->prev
= new;
2241 p
->parent
= o
->parent
;
2244 Fset_window_buffer (new, o
->buffer
);
2246 /* Apportion the available frame space among the two new windows */
2248 if (!NILP (horflag
))
2250 p
->height
= o
->height
;
2252 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size
);
2253 XSETFASTINT (o
->width
, size
);
2254 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size
);
2259 p
->width
= o
->width
;
2260 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size
);
2261 XSETFASTINT (o
->height
, size
);
2262 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size
);
2268 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2269 "Make current window ARG lines bigger.\n\
2270 From program, optional second arg non-nil means grow sideways ARG columns.")
2272 register Lisp_Object n
, side
;
2274 CHECK_NUMBER (n
, 0);
2275 change_window_height (XINT (n
), !NILP (side
));
2279 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2280 "Make current window ARG lines smaller.\n\
2281 From program, optional second arg non-nil means shrink sideways ARG columns.")
2283 register Lisp_Object n
, side
;
2285 CHECK_NUMBER (n
, 0);
2286 change_window_height (-XINT (n
), !NILP (side
));
2291 window_height (window
)
2294 register struct window
*p
= XWINDOW (window
);
2295 return XFASTINT (p
->height
);
2299 window_width (window
)
2302 register struct window
*p
= XWINDOW (window
);
2303 return XFASTINT (p
->width
);
2306 #define MINSIZE(w) \
2308 ? window_min_width \
2309 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2312 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2314 #define CURSIZE(w) \
2315 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2317 /* Unlike set_window_height, this function
2318 also changes the heights of the siblings so as to
2319 keep everything consistent. */
2321 change_window_height (delta
, widthflag
)
2325 register Lisp_Object parent
;
2327 register struct window
*p
;
2329 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2330 register int (*setsizefun
) () = (widthflag
2332 : set_window_height
);
2334 check_min_window_sizes ();
2336 window
= selected_window
;
2339 p
= XWINDOW (window
);
2344 error ("No other window to side of this one");
2347 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2348 : !NILP (XWINDOW (parent
)->vchild
))
2353 sizep
= &CURSIZE (window
);
2356 register int maxdelta
;
2358 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2359 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2360 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2361 /* This is a frame with only one window, a minibuffer-only
2362 or a minibufferless frame. */
2365 if (delta
> maxdelta
)
2366 /* This case traps trying to make the minibuffer
2367 the full frame, or make the only window aside from the
2368 minibuffer the full frame. */
2372 if (*sizep
+ delta
< MINSIZE (window
))
2374 Fdelete_window (window
);
2382 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2384 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2385 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2386 CURBEG (p
->next
) += delta
;
2387 /* This does not change size of p->next,
2388 but it propagates the new top edge to its children */
2389 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2391 else if (!NILP (p
->prev
)
2392 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2394 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2395 CURBEG (window
) -= delta
;
2396 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2400 register int delta1
;
2401 register int opht
= (*sizefun
) (parent
);
2403 /* If trying to grow this window to or beyond size of the parent,
2404 make delta1 so big that, on shrinking back down,
2405 all the siblings end up with less than one line and are deleted. */
2406 if (opht
<= *sizep
+ delta
)
2407 delta1
= opht
* opht
* 2;
2408 /* Otherwise, make delta1 just right so that if we add delta1
2409 lines to this window and to the parent, and then shrink
2410 the parent back to its original size, the new proportional
2411 size of this window will increase by delta. */
2413 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2415 /* Add delta1 lines or columns to this window, and to the parent,
2416 keeping things consistent while not affecting siblings. */
2417 CURSIZE (parent
) = opht
+ delta1
;
2418 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2420 /* Squeeze out delta1 lines or columns from our parent,
2421 shriking this window and siblings proportionately.
2422 This brings parent back to correct size.
2423 Delta1 was calculated so this makes this window the desired size,
2424 taking it all out of the siblings. */
2425 (*setsizefun
) (parent
, opht
, 0);
2428 XSETFASTINT (p
->last_modified
, 0);
2435 /* Return number of lines of text (not counting mode line) in W. */
2438 window_internal_height (w
)
2441 int ht
= XFASTINT (w
->height
);
2443 if (MINI_WINDOW_P (w
))
2446 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2447 || !NILP (w
->next
) || !NILP (w
->prev
)
2448 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2455 /* Return the number of columns in W.
2456 Don't count columns occupied by scroll bars or the vertical bar
2457 separating W from the sibling to its right. */
2459 window_internal_width (w
)
2462 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2463 int left
= XINT (w
->left
);
2464 int width
= XINT (w
->width
);
2466 /* If this window is flush against the right edge of the frame, its
2467 internal width is its full width. */
2468 if (left
+ width
>= FRAME_WIDTH (f
))
2471 /* If we are not flush right, then our rightmost columns are
2472 occupied by some sort of separator. */
2474 /* Scroll bars occupy a few columns. */
2475 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2476 return width
- FRAME_SCROLL_BAR_COLS (f
);
2478 /* The column of `|' characters separating side-by-side windows
2479 occupies one column only. */
2484 /* Scroll contents of window WINDOW up N lines. */
2487 window_scroll (window
, n
, noerror
)
2492 register struct window
*w
= XWINDOW (window
);
2493 register int opoint
= PT
;
2495 register int ht
= window_internal_height (w
);
2496 register Lisp_Object tem
;
2498 Lisp_Object bolp
, nmoved
;
2500 XSETFASTINT (tem
, PT
);
2501 tem
= Fpos_visible_in_window_p (tem
, window
);
2505 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2506 XSETFASTINT (tem
, PT
);
2507 Fset_marker (w
->start
, tem
, w
->buffer
);
2508 w
->force_start
= Qt
;
2511 SET_PT (marker_position (w
->start
));
2512 lose
= n
< 0 && PT
== BEGV
;
2513 Fvertical_motion (make_number (n
), window
);
2523 Fsignal (Qbeginning_of_buffer
, Qnil
);
2528 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2529 w
->start_at_line_beg
= bolp
;
2530 w
->update_mode_line
= Qt
;
2531 XSETFASTINT (w
->last_modified
, 0);
2537 tem
= Fvertical_motion (make_number (ht
), window
);
2538 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2541 Fvertical_motion (make_number (-1), window
);
2549 Fsignal (Qend_of_buffer
, Qnil
);
2553 /* This is the guts of Fscroll_up and Fscroll_down. */
2556 scroll_command (n
, direction
)
2557 register Lisp_Object n
;
2560 register int defalt
;
2561 int count
= specpdl_ptr
- specpdl
;
2563 /* If selected window's buffer isn't current, make it current for the moment.
2564 But don't screw up if window_scroll gets an error. */
2565 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2567 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2568 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2571 defalt
= (window_internal_height (XWINDOW (selected_window
))
2572 - next_screen_context_lines
);
2573 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2576 window_scroll (selected_window
, defalt
, 0);
2577 else if (EQ (n
, Qminus
))
2578 window_scroll (selected_window
, - defalt
, 0);
2581 n
= Fprefix_numeric_value (n
);
2582 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2585 unbind_to (count
, Qnil
);
2588 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2589 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2590 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2591 Negative ARG means scroll downward.\n\
2592 When calling from a program, supply a number as argument or nil.")
2596 scroll_command (n
, 1);
2600 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2601 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2602 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2603 Negative ARG means scroll upward.\n\
2604 When calling from a program, supply a number as argument or nil.")
2608 scroll_command (n
, -1);
2612 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2613 "Return the other window for \"other window scroll\" commands.\n\
2614 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2615 specifies the window.\n\
2616 If `other-window-scroll-buffer' is non-nil, a window\n\
2617 showing that buffer is used.")
2622 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2623 && !NILP (Vminibuf_scroll_window
))
2624 window
= Vminibuf_scroll_window
;
2625 /* If buffer is specified, scroll that buffer. */
2626 else if (!NILP (Vother_window_scroll_buffer
))
2628 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2630 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2634 /* Nothing specified; look for a neighboring window on the same
2636 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2638 if (EQ (window
, selected_window
))
2639 /* That didn't get us anywhere; look for a window on another
2642 window
= Fnext_window (window
, Qnil
, Qt
);
2643 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2644 && ! EQ (window
, selected_window
));
2647 CHECK_LIVE_WINDOW (window
, 0);
2649 if (EQ (window
, selected_window
))
2650 error ("There is no other window");
2655 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2656 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2657 The next window is the one below the current one; or the one at the top\n\
2658 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2659 When calling from a program, supply a number as argument or nil.\n\
2661 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2662 specifies the window to scroll.\n\
2663 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2664 showing that buffer, popping the buffer up if necessary.")
2666 register Lisp_Object n
;
2668 register Lisp_Object window
;
2669 register int defalt
;
2670 register struct window
*w
;
2671 register int count
= specpdl_ptr
- specpdl
;
2673 window
= Fother_window_for_scrolling ();
2675 w
= XWINDOW (window
);
2676 defalt
= window_internal_height (w
) - next_screen_context_lines
;
2677 if (defalt
< 1) defalt
= 1;
2679 /* Don't screw up if window_scroll gets an error. */
2680 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2682 Fset_buffer (w
->buffer
);
2683 SET_PT (marker_position (w
->pointm
));
2686 window_scroll (window
, defalt
, 1);
2687 else if (EQ (n
, Qminus
))
2688 window_scroll (window
, -defalt
, 1);
2693 CHECK_NUMBER (n
, 0);
2694 window_scroll (window
, XINT (n
), 1);
2697 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2698 unbind_to (count
, Qnil
);
2703 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2704 "Scroll selected window display ARG columns left.\n\
2705 Default for ARG is window width minus 2.")
2707 register Lisp_Object arg
;
2711 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2713 arg
= Fprefix_numeric_value (arg
);
2716 Fset_window_hscroll (selected_window
,
2717 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2721 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2722 "Scroll selected window display ARG columns right.\n\
2723 Default for ARG is window width minus 2.")
2725 register Lisp_Object arg
;
2728 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2730 arg
= Fprefix_numeric_value (arg
);
2733 Fset_window_hscroll (selected_window
,
2734 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2738 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2739 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2740 The desired position of point is always relative to the current window.\n\
2741 Just C-u as prefix means put point in the center of the window.\n\
2742 No arg (i.e., it is nil) erases the entire frame and then\n\
2743 redraws with point in the center of the current window.")
2745 register Lisp_Object n
;
2747 register struct window
*w
= XWINDOW (selected_window
);
2748 register int ht
= window_internal_height (w
);
2749 struct position pos
;
2754 extern int frame_garbaged
;
2756 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2757 XSETFASTINT (n
, ht
/ 2);
2759 else if (CONSP (n
)) /* Just C-u. */
2761 XSETFASTINT (n
, ht
/ 2);
2765 n
= Fprefix_numeric_value (n
);
2766 CHECK_NUMBER (n
, 0);
2770 XSETINT (n
, XINT (n
) + ht
);
2772 XSETWINDOW (window
, w
);
2773 pos
= *vmotion (point
, - XINT (n
), window_internal_width (w
) - 1,
2774 XINT (w
->hscroll
), window
);
2776 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
2777 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
2778 || FETCH_CHAR (pos
.bufpos
- 1) == '\n')
2780 w
->force_start
= Qt
;
2785 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2787 "Position point relative to window.\n\
2788 With no argument, position point at center of window.\n\
2789 An argument specifies frame line; zero means top of window,\n\
2790 negative means relative to bottom of window.")
2792 register Lisp_Object arg
;
2794 register struct window
*w
= XWINDOW (selected_window
);
2795 register int height
= window_internal_height (w
);
2800 XSETFASTINT (arg
, height
/ 2);
2803 arg
= Fprefix_numeric_value (arg
);
2805 XSETINT (arg
, XINT (arg
) + height
);
2808 start
= marker_position (w
->start
);
2809 XSETWINDOW (window
, w
);
2810 if (start
< BEGV
|| start
> ZV
)
2812 Fvertical_motion (make_number (- (height
/ 2)), window
);
2813 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2814 w
->start_at_line_beg
= Fbolp ();
2815 w
->force_start
= Qt
;
2820 return Fvertical_motion (arg
, window
);
2823 struct save_window_data
2825 int size_from_Lisp_Vector_struct
;
2826 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2827 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2828 Lisp_Object selected_frame
;
2829 Lisp_Object current_window
;
2830 Lisp_Object current_buffer
;
2831 Lisp_Object minibuf_scroll_window
;
2832 Lisp_Object root_window
;
2833 Lisp_Object focus_frame
;
2834 /* Record the values of window-min-width and window-min-height
2835 so that window sizes remain consistent with them. */
2836 Lisp_Object min_width
, min_height
;
2837 /* A vector, interpreted as a struct saved_window */
2838 Lisp_Object saved_windows
;
2841 /* This is saved as a Lisp_Vector */
2844 /* these first two must agree with struct Lisp_Vector in lisp.h */
2845 int size_from_Lisp_Vector_struct
;
2846 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2849 Lisp_Object buffer
, start
, pointm
, mark
;
2850 Lisp_Object left
, top
, width
, height
, hscroll
;
2851 Lisp_Object parent
, prev
;
2852 Lisp_Object start_at_line_beg
;
2853 Lisp_Object display_table
;
2855 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2857 #define SAVED_WINDOW_N(swv,n) \
2858 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2860 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2861 "T if OBJECT is a window-configration object.")
2865 if (WINDOW_CONFIGURATIONP (obj
))
2871 DEFUN ("set-window-configuration", Fset_window_configuration
,
2872 Sset_window_configuration
, 1, 1, 0,
2873 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2874 CONFIGURATION must be a value previously returned\n\
2875 by `current-window-configuration' (which see).")
2877 Lisp_Object configuration
;
2879 register struct save_window_data
*data
;
2880 struct Lisp_Vector
*saved_windows
;
2881 Lisp_Object new_current_buffer
;
2885 while (!WINDOW_CONFIGURATIONP (configuration
))
2887 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2891 data
= (struct save_window_data
*) XVECTOR (configuration
);
2892 saved_windows
= XVECTOR (data
->saved_windows
);
2894 new_current_buffer
= data
->current_buffer
;
2895 if (NILP (XBUFFER (new_current_buffer
)->name
))
2896 new_current_buffer
= Qnil
;
2898 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2901 /* If f is a dead frame, don't bother rebuilding its window tree.
2902 However, there is other stuff we should still try to do below. */
2903 if (FRAME_LIVE_P (f
))
2905 register struct window
*w
;
2906 register struct saved_window
*p
;
2909 /* If the frame has been resized since this window configuration was
2910 made, we change the frame to the size specified in the
2911 configuration, restore the configuration, and then resize it
2912 back. We keep track of the prevailing height in these variables. */
2913 int previous_frame_height
= FRAME_HEIGHT (f
);
2914 int previous_frame_width
= FRAME_WIDTH (f
);
2915 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2917 if (XFASTINT (data
->frame_height
) != previous_frame_height
2918 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2919 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2920 #ifdef HAVE_X_WINDOWS
2921 if (XFASTINT (data
->frame_menu_bar_lines
)
2922 != previous_frame_menu_bar_lines
)
2923 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2926 windows_or_buffers_changed
++;
2927 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2929 /* Temporarily avoid any problems with windows that are smaller
2930 than they are supposed to be. */
2931 window_min_height
= 1;
2932 window_min_width
= 1;
2935 Mark all windows now on frame as "deleted".
2936 Restoring the new configuration "undeletes" any that are in it.
2938 Save their current buffers in their height fields, since we may
2939 need it later, if a buffer saved in the configuration is now
2941 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2943 for (k
= 0; k
< saved_windows
->size
; k
++)
2945 p
= SAVED_WINDOW_N (saved_windows
, k
);
2946 w
= XWINDOW (p
->window
);
2949 if (!NILP (p
->parent
))
2950 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2951 XFASTINT (p
->parent
))->window
;
2955 if (!NILP (p
->prev
))
2957 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2958 XFASTINT (p
->prev
))->window
;
2959 XWINDOW (w
->prev
)->next
= p
->window
;
2964 if (!NILP (w
->parent
))
2966 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2968 XWINDOW (w
->parent
)->vchild
= p
->window
;
2969 XWINDOW (w
->parent
)->hchild
= Qnil
;
2973 XWINDOW (w
->parent
)->hchild
= p
->window
;
2974 XWINDOW (w
->parent
)->vchild
= Qnil
;
2979 /* If we squirreled away the buffer in the window's height,
2981 if (BUFFERP (w
->height
))
2982 w
->buffer
= w
->height
;
2985 w
->width
= p
->width
;
2986 w
->height
= p
->height
;
2987 w
->hscroll
= p
->hscroll
;
2988 w
->display_table
= p
->display_table
;
2989 XSETFASTINT (w
->last_modified
, 0);
2991 /* Reinstall the saved buffer and pointers into it. */
2992 if (NILP (p
->buffer
))
2993 w
->buffer
= p
->buffer
;
2996 if (!NILP (XBUFFER (p
->buffer
)->name
))
2997 /* If saved buffer is alive, install it. */
2999 w
->buffer
= p
->buffer
;
3000 w
->start_at_line_beg
= p
->start_at_line_beg
;
3001 set_marker_restricted (w
->start
,
3002 Fmarker_position (p
->start
),
3004 set_marker_restricted (w
->pointm
,
3005 Fmarker_position (p
->pointm
),
3007 Fset_marker (XBUFFER (w
->buffer
)->mark
,
3008 Fmarker_position (p
->mark
), w
->buffer
);
3010 /* As documented in Fcurrent_window_configuration, don't
3011 save the location of point in the buffer which was current
3012 when the window configuration was recorded. */
3013 if (!EQ (p
->buffer
, new_current_buffer
)
3014 && XBUFFER (p
->buffer
) == current_buffer
)
3015 Fgoto_char (w
->pointm
);
3017 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
3018 /* Else unless window has a live buffer, get one. */
3020 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
3021 /* This will set the markers to beginning of visible
3023 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
3024 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
3025 w
->start_at_line_beg
= Qt
;
3028 /* Keeping window's old buffer; make sure the markers
3031 /* Set window markers at start of visible range. */
3032 if (XMARKER (w
->start
)->buffer
== 0)
3033 set_marker_restricted (w
->start
, make_number (0),
3035 if (XMARKER (w
->pointm
)->buffer
== 0)
3036 set_marker_restricted (w
->pointm
,
3038 (BUF_PT (XBUFFER (w
->buffer
)))),
3040 w
->start_at_line_beg
= Qt
;
3045 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
3046 Fselect_window (data
->current_window
);
3049 if (NILP (data
->focus_frame
)
3050 || (FRAMEP (data
->focus_frame
)
3051 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
3052 Fredirect_frame_focus (frame
, data
->focus_frame
);
3055 #if 0 /* I don't understand why this is needed, and it causes problems
3056 when the frame's old selected window has been deleted. */
3058 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
3059 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
3063 /* Set the screen height to the value it had before this function. */
3064 if (previous_frame_height
!= FRAME_HEIGHT (f
)
3065 || previous_frame_width
!= FRAME_WIDTH (f
))
3066 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
3068 #ifdef HAVE_X_WINDOWS
3069 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
3070 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
3074 /* Restore the minimum heights recorded in the configuration. */
3075 window_min_height
= XINT (data
->min_height
);
3076 window_min_width
= XINT (data
->min_width
);
3079 /* Fselect_window will have made f the selected frame, so we
3080 reselect the proper frame here. Fhandle_switch_frame will change the
3081 selected window too, but that doesn't make the call to
3082 Fselect_window above totally superfluous; it still sets f's
3084 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
3085 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
3088 if (!NILP (new_current_buffer
))
3089 Fset_buffer (new_current_buffer
);
3091 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
3095 /* Mark all windows now on frame as deleted
3096 by setting their buffers to nil. */
3099 delete_all_subwindows (w
)
3100 register struct window
*w
;
3102 if (!NILP (w
->next
))
3103 delete_all_subwindows (XWINDOW (w
->next
));
3104 if (!NILP (w
->vchild
))
3105 delete_all_subwindows (XWINDOW (w
->vchild
));
3106 if (!NILP (w
->hchild
))
3107 delete_all_subwindows (XWINDOW (w
->hchild
));
3109 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3111 /* We set all three of these fields to nil, to make sure that we can
3112 distinguish this dead window from any live window. Live leaf
3113 windows will have buffer set, and combination windows will have
3114 vchild or hchild set. */
3121 count_windows (window
)
3122 register struct window
*window
;
3124 register int count
= 1;
3125 if (!NILP (window
->next
))
3126 count
+= count_windows (XWINDOW (window
->next
));
3127 if (!NILP (window
->vchild
))
3128 count
+= count_windows (XWINDOW (window
->vchild
));
3129 if (!NILP (window
->hchild
))
3130 count
+= count_windows (XWINDOW (window
->hchild
));
3135 save_window_save (window
, vector
, i
)
3137 struct Lisp_Vector
*vector
;
3140 register struct saved_window
*p
;
3141 register struct window
*w
;
3142 register Lisp_Object tem
;
3144 for (;!NILP (window
); window
= w
->next
)
3146 p
= SAVED_WINDOW_N (vector
, i
);
3147 w
= XWINDOW (window
);
3149 XSETFASTINT (w
->temslot
, i
++);
3151 p
->buffer
= w
->buffer
;
3154 p
->width
= w
->width
;
3155 p
->height
= w
->height
;
3156 p
->hscroll
= w
->hscroll
;
3157 p
->display_table
= w
->display_table
;
3158 if (!NILP (w
->buffer
))
3160 /* Save w's value of point in the window configuration.
3161 If w is the selected window, then get the value of point
3162 from the buffer; pointm is garbage in the selected window. */
3163 if (EQ (window
, selected_window
))
3165 p
->pointm
= Fmake_marker ();
3166 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
3170 p
->pointm
= Fcopy_marker (w
->pointm
);
3172 p
->start
= Fcopy_marker (w
->start
);
3173 p
->start_at_line_beg
= w
->start_at_line_beg
;
3175 tem
= XBUFFER (w
->buffer
)->mark
;
3176 p
->mark
= Fcopy_marker (tem
);
3183 p
->start_at_line_beg
= Qnil
;
3186 if (NILP (w
->parent
))
3189 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3194 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3196 if (!NILP (w
->vchild
))
3197 i
= save_window_save (w
->vchild
, vector
, i
);
3198 if (!NILP (w
->hchild
))
3199 i
= save_window_save (w
->hchild
, vector
, i
);
3205 DEFUN ("current-window-configuration",
3206 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3207 "Return an object representing the current window configuration of FRAME.\n\
3208 If FRAME is nil or omitted, use the selected frame.\n\
3209 This describes the number of windows, their sizes and current buffers,\n\
3210 and for each displayed buffer, where display starts, and the positions of\n\
3211 point and mark. An exception is made for point in the current buffer:\n\
3212 its value is -not- saved.\n\
3213 This also records the currently selected frame, and FRAME's focus\n\
3214 redirection (see `redirect-frame-focus').")
3218 register Lisp_Object tem
;
3219 register int n_windows
;
3220 register struct save_window_data
*data
;
3221 register struct Lisp_Vector
*vec
;
3229 CHECK_LIVE_FRAME (frame
, 0);
3233 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3234 vec
= allocate_vectorlike (VECSIZE (struct save_window_data
));
3235 for (i
= 0; i
< VECSIZE (struct save_window_data
); i
++)
3236 vec
->contents
[i
] = Qnil
;
3237 vec
->size
= VECSIZE (struct save_window_data
);
3238 data
= (struct save_window_data
*)vec
;
3240 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
3241 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
3242 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
3244 XSETFRAME (data
->selected_frame
, selected_frame
);
3246 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3247 XSETBUFFER (data
->current_buffer
, current_buffer
);
3248 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3249 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3250 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3251 XSETINT (data
->min_height
, window_min_height
);
3252 XSETINT (data
->min_width
, window_min_width
);
3253 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3254 data
->saved_windows
= tem
;
3255 for (i
= 0; i
< n_windows
; i
++)
3256 XVECTOR (tem
)->contents
[i
]
3257 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3258 save_window_save (FRAME_ROOT_WINDOW (f
),
3260 XSETWINDOW_CONFIGURATION (tem
, data
);
3264 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3266 "Execute body, preserving window sizes and contents.\n\
3267 Restore which buffer appears in which window, where display starts,\n\
3268 and the value of point and mark for each window.\n\
3269 Also restore which buffer is current.\n\
3270 But do not preserve point in the current buffer.\n\
3271 Does not restore the value of point in current buffer.")
3275 register Lisp_Object val
;
3276 register int count
= specpdl_ptr
- specpdl
;
3278 record_unwind_protect (Fset_window_configuration
,
3279 Fcurrent_window_configuration (Qnil
));
3280 val
= Fprogn (args
);
3281 return unbind_to (count
, val
);
3287 selected_frame
= make_terminal_frame ();
3288 minibuf_window
= selected_frame
->minibuffer_window
;
3289 selected_window
= selected_frame
->selected_window
;
3290 last_nonminibuf_frame
= selected_frame
;
3291 #else /* not MULTI_FRAME */
3292 extern Lisp_Object
get_minibuffer ();
3294 selected_frame
= last_nonminibuf_frame
= &the_only_frame
;
3296 minibuf_window
= make_window ();
3297 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3299 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3300 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3301 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3303 /* These values 9 and 10 are arbitrary,
3304 just so that there is "something there."
3305 Correct values are put in in init_xdisp */
3307 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
, 10);
3308 XSETFASTINT (XWINDOW (minibuf_window
)->width
, 10);
3310 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
, 9);
3311 XSETFASTINT (XWINDOW (minibuf_window
)->top
, 9);
3312 XSETFASTINT (XWINDOW (minibuf_window
)->height
, 1);
3314 /* Prevent error in Fset_window_buffer. */
3315 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3316 XWINDOW (minibuf_window
)->buffer
= Qt
;
3318 /* Now set them up for real. */
3319 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3320 Fcurrent_buffer ());
3321 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3323 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3324 /* Make sure this window seems more recently used than
3325 a newly-created, never-selected window. Increment
3326 window_select_count so the first selection ever will get
3327 something newer than this. */
3328 XSETFASTINT (XWINDOW (selected_window
)->use_time
, ++window_select_count
);
3329 #endif /* not MULTI_FRAME */
3334 Qwindowp
= intern ("windowp");
3335 staticpro (&Qwindowp
);
3337 Qwindow_live_p
= intern ("window-live-p");
3338 staticpro (&Qwindow_live_p
);
3340 Qtemp_buffer_show_hook
= intern ("Qtemp-buffer-show-hook");
3341 staticpro (&Qtemp_buffer_show_hook
);
3344 /* Make sure all windows get marked */
3345 staticpro (&minibuf_window
);
3348 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3349 "Non-nil means call as function to display a help buffer.\n\
3350 The function is called with one argument, the buffer to be displayed.\n\
3351 Used by `with-output-to-temp-buffer'.");
3352 Vtemp_buffer_show_function
= Qnil
;
3354 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3355 "If non-nil, function to call to handle `display-buffer'.\n\
3356 It will receive two args, the buffer and a flag which if non-nil means\n\
3357 that the currently selected window is not acceptable.\n\
3358 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3359 work using this function.");
3360 Vdisplay_buffer_function
= Qnil
;
3362 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3363 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3364 Vminibuf_scroll_window
= Qnil
;
3366 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3367 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3368 Vother_window_scroll_buffer
= Qnil
;
3370 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3371 "*Non-nil means `display-buffer' should make a separate frame.");
3374 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3375 "Function to call to handle automatic new frame creation.\n\
3376 It is called with no arguments and should return a newly created frame.\n\
3378 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3379 where `pop-up-frame-alist' would hold the default frame parameters.");
3380 Vpop_up_frame_function
= Qnil
;
3382 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3383 "*List of buffer names that should have their own special frames.\n\
3384 Displaying a buffer whose name is in this list makes a special frame for it\n\
3385 using `special-display-function'.\n\
3387 An element of the list can be a cons cell instead of just a string.\n\
3388 Then the car should be a buffer name, and the cdr specifies frame\n\
3389 parameters for creating the frame for that buffer.\n\
3390 More precisely, the cdr is passed as the second argument to\n\
3391 the function found in `special-display-function', when making that frame.\n\
3392 See also `special-display-regexps'.");
3393 Vspecial_display_buffer_names
= Qnil
;
3395 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3396 "*List of regexps saying which buffers should have their own special frames.\n\
3397 If a buffer name matches one of these regexps, it gets its own frame.\n\
3398 Displaying a buffer whose name is in this list makes a special frame for it\n\
3399 using `special-display-function'.\n\
3401 An element of the list can be a cons cell instead of just a string.\n\
3402 Then the car should be the regexp, and the cdr specifies frame\n\
3403 parameters for creating the frame for buffers that match.\n\
3404 More precisely, the cdr is passed as the second argument to\n\
3405 the function found in `special-display-function', when making that frame.\n\
3406 See also `special-display-buffer-names'.");
3407 Vspecial_display_regexps
= Qnil
;
3409 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3410 "Function to call to make a new frame for a special buffer.\n\
3411 It is called with two arguments, the buffer and optional buffer specific\n\
3412 data, and should return a window displaying that buffer.\n\
3413 The default value makes a separate frame for the buffer,\n\
3414 using `special-display-frame-alist' to specify the frame parameters.\n\
3416 A buffer is special if its is listed in `special-display-buffer-names'\n\
3417 or matches a regexp in `special-display-regexps'.");
3418 Vspecial_display_function
= Qnil
;
3420 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
3421 "*List of buffer names that should appear in the selected window.\n\
3422 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
3423 switches to it in the selected window, rather than making it appear\n\
3424 in some other window.\n\
3426 An element of the list can be a cons cell instead of just a string.\n\
3427 Then the car must be a string, which specifies the buffer name.\n\
3428 This is for compatibility with `special-display-buffer-names';\n\
3429 the cdr of the cons cell is ignored.\n\
3431 See also `same-window-regexps'.");
3432 Vsame_window_buffer_names
= Qnil
;
3434 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
3435 "*List of regexps saying which buffers should appear in the selected window.\n\
3436 If a buffer name matches one of these regexps, then displaying it\n\
3437 using `display-buffer' or `pop-to-buffer' switches to it\n\
3438 in the selected window, rather than making it appear in some other window.\n\
3440 An element of the list can be a cons cell instead of just a string.\n\
3441 Then the car must be a string, which specifies the buffer name.\n\
3442 This is for compatibility with `special-display-buffer-names';\n\
3443 the cdr of the cons cell is ignored.\n\
3445 See also `same-window-buffer-names'.");
3446 Vsame_window_regexps
= Qnil
;
3448 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3449 "*Non-nil means display-buffer should make new windows.");
3452 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3453 "*Number of lines of continuity when scrolling by screenfuls.");
3454 next_screen_context_lines
= 2;
3456 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3457 "*display-buffer would prefer to split the largest window if this large.\n\
3458 If there is only one window, it is split regardless of this value.");
3459 split_height_threshold
= 500;
3461 DEFVAR_INT ("window-min-height", &window_min_height
,
3462 "*Delete any window less than this tall (including its mode line).");
3463 window_min_height
= 4;
3465 DEFVAR_INT ("window-min-width", &window_min_width
,
3466 "*Delete any window less than this wide.");
3467 window_min_width
= 10;
3469 defsubr (&Sselected_window
);
3470 defsubr (&Sminibuffer_window
);
3471 defsubr (&Swindow_minibuffer_p
);
3472 defsubr (&Swindowp
);
3473 defsubr (&Swindow_live_p
);
3474 defsubr (&Spos_visible_in_window_p
);
3475 defsubr (&Swindow_buffer
);
3476 defsubr (&Swindow_height
);
3477 defsubr (&Swindow_width
);
3478 defsubr (&Swindow_hscroll
);
3479 defsubr (&Sset_window_hscroll
);
3480 defsubr (&Swindow_edges
);
3481 defsubr (&Scoordinates_in_window_p
);
3482 defsubr (&Swindow_at
);
3483 defsubr (&Swindow_point
);
3484 defsubr (&Swindow_start
);
3485 defsubr (&Swindow_end
);
3486 defsubr (&Sset_window_point
);
3487 defsubr (&Sset_window_start
);
3488 defsubr (&Swindow_dedicated_p
);
3489 defsubr (&Sset_window_dedicated_p
);
3490 defsubr (&Swindow_display_table
);
3491 defsubr (&Sset_window_display_table
);
3492 defsubr (&Snext_window
);
3493 defsubr (&Sprevious_window
);
3494 defsubr (&Sother_window
);
3495 defsubr (&Sget_lru_window
);
3496 defsubr (&Sget_largest_window
);
3497 defsubr (&Sget_buffer_window
);
3498 defsubr (&Sdelete_other_windows
);
3499 defsubr (&Sdelete_windows_on
);
3500 defsubr (&Sreplace_buffer_in_windows
);
3501 defsubr (&Sdelete_window
);
3502 defsubr (&Sset_window_buffer
);
3503 defsubr (&Sselect_window
);
3504 defsubr (&Sdisplay_buffer
);
3505 defsubr (&Ssplit_window
);
3506 defsubr (&Senlarge_window
);
3507 defsubr (&Sshrink_window
);
3508 defsubr (&Sscroll_up
);
3509 defsubr (&Sscroll_down
);
3510 defsubr (&Sscroll_left
);
3511 defsubr (&Sscroll_right
);
3512 defsubr (&Sother_window_for_scrolling
);
3513 defsubr (&Sscroll_other_window
);
3514 defsubr (&Srecenter
);
3515 defsubr (&Smove_to_window_line
);
3516 defsubr (&Swindow_configuration_p
);
3517 defsubr (&Sset_window_configuration
);
3518 defsubr (&Scurrent_window_configuration
);
3519 defsubr (&Ssave_window_excursion
);
3524 initial_define_key (control_x_map
, '1', "delete-other-windows");
3525 initial_define_key (control_x_map
, '2', "split-window");
3526 initial_define_key (control_x_map
, '0', "delete-window");
3527 initial_define_key (control_x_map
, 'o', "other-window");
3528 initial_define_key (control_x_map
, '^', "enlarge-window");
3529 initial_define_key (control_x_map
, '<', "scroll-left");
3530 initial_define_key (control_x_map
, '>', "scroll-right");
3532 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3533 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3534 initial_define_key (meta_map
, 'v', "scroll-down");
3536 initial_define_key (global_map
, Ctl('L'), "recenter");
3537 initial_define_key (meta_map
, 'r', "move-to-window-line");