1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985,86,87,93,94,95,96,1997 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 #include "blockinput.h"
34 Lisp_Object Qwindowp
, Qwindow_live_p
;
36 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
37 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
39 void delete_all_subwindows ();
40 static struct window
*decode_window();
42 /* This is the window in which the terminal's cursor should
43 be left when nothing is being done with it. This must
44 always be a leaf window, and its buffer is selected by
45 the top level editing loop at the end of each command.
47 This value is always the same as
48 FRAME_SELECTED_WINDOW (selected_frame). */
50 Lisp_Object selected_window
;
52 /* The minibuffer window of the selected frame.
53 Note that you cannot test for minibufferness of an arbitrary window
54 by comparing against this; but you can test for minibufferness of
55 the selected window. */
56 Lisp_Object minibuf_window
;
58 /* Non-nil means it is the window for C-M-v to scroll
59 when the minibuffer is selected. */
60 Lisp_Object Vminibuf_scroll_window
;
62 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
63 Lisp_Object Vother_window_scroll_buffer
;
65 /* Non-nil means it's function to call to display temp buffers. */
66 Lisp_Object Vtemp_buffer_show_function
;
68 /* If a window gets smaller than either of these, it is removed. */
69 int window_min_height
;
72 /* Nonzero implies Fdisplay_buffer should create windows. */
75 /* Nonzero implies make new frames for Fdisplay_buffer. */
78 /* Non-nil means use this function instead of default */
79 Lisp_Object Vpop_up_frame_function
;
81 /* Function to call to handle Fdisplay_buffer. */
82 Lisp_Object Vdisplay_buffer_function
;
84 /* List of buffer *names* for buffers that should have their own frames. */
85 Lisp_Object Vspecial_display_buffer_names
;
87 /* List of regexps for buffer names that should have their own frames. */
88 Lisp_Object Vspecial_display_regexps
;
90 /* Function to pop up a special frame. */
91 Lisp_Object Vspecial_display_function
;
93 /* List of buffer *names* for buffers to appear in selected window. */
94 Lisp_Object Vsame_window_buffer_names
;
96 /* List of regexps for buffer names to appear in selected window. */
97 Lisp_Object Vsame_window_regexps
;
99 /* Hook run at end of temp_output_buffer_show. */
100 Lisp_Object Qtemp_buffer_show_hook
;
102 /* Fdisplay_buffer always splits the largest window
103 if that window is more than this high. */
104 int split_height_threshold
;
106 /* Number of lines of continuity in scrolling by screenfuls. */
107 int next_screen_context_lines
;
109 /* Incremented for each window created. */
110 static int sequence_number
;
112 /* Nonzero after init_window_once has finished. */
113 static int window_initialized
;
115 /* Hook to run when window config changes. */
116 Lisp_Object Qwindow_configuration_change_hook
;
117 Lisp_Object Vwindow_configuration_change_hook
;
119 /* Nonzero means scroll commands try to put point
120 at the same screen height as previously. */
121 static int scroll_preserve_screen_position
;
123 /* Nonzero means we can split a frame even if it is "unsplittable". */
124 static int inhibit_frame_unsplittable
;
126 #define min(a, b) ((a) < (b) ? (a) : (b))
128 extern int scroll_margin
;
130 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
132 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
133 "Returns t if OBJECT is a window.")
137 return WINDOWP (object
) ? Qt
: Qnil
;
140 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
141 "Returns t if OBJECT is a window which is currently visible.")
145 return (WINDOWP (object
) && ! NILP (XWINDOW (object
)->buffer
) ? Qt
: Qnil
);
152 register struct window
*p
;
153 register struct Lisp_Vector
*vec
;
156 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct window
));
157 for (i
= 0; i
< VECSIZE (struct window
); i
++)
158 vec
->contents
[i
] = Qnil
;
159 vec
->size
= VECSIZE (struct window
);
160 p
= (struct window
*)vec
;
161 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
162 XSETFASTINT (p
->left
, 0);
163 XSETFASTINT (p
->top
, 0);
164 XSETFASTINT (p
->height
, 0);
165 XSETFASTINT (p
->width
, 0);
166 XSETFASTINT (p
->hscroll
, 0);
167 XSETFASTINT (p
->last_point_x
, 0);
168 XSETFASTINT (p
->last_point_y
, 0);
169 p
->start
= Fmake_marker ();
170 p
->pointm
= Fmake_marker ();
171 XSETFASTINT (p
->use_time
, 0);
173 p
->display_table
= Qnil
;
179 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
180 "Return the window that the cursor now appears in and commands apply to.")
183 return selected_window
;
186 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
187 "Return the window used now for minibuffers.\n\
188 If the optional argument FRAME is specified, return the minibuffer window\n\
189 used by that frame.")
194 XSETFRAME (frame
, selected_frame
);
196 CHECK_LIVE_FRAME (frame
, 0);
198 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
201 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
202 "Returns non-nil if WINDOW is a minibuffer window.")
206 struct window
*w
= decode_window (window
);
207 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
210 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
211 Spos_visible_in_window_p
, 0, 2, 0,
212 "Return t if position POS is currently on the frame in WINDOW.\n\
213 Returns nil if that position is scrolled vertically out of view.\n\
214 POS defaults to point; WINDOW, to the selected window.")
216 Lisp_Object pos
, window
;
218 register struct window
*w
;
222 register struct buffer
*buf
;
223 struct position posval
;
230 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
234 w
= decode_window (window
);
235 top
= marker_position (w
->start
);
236 hscroll
= XINT (w
->hscroll
);
241 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
243 buf
= XBUFFER (w
->buffer
);
244 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
)
245 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (buf
))
247 /* If frame is up to date,
248 use the info recorded about how much text fit on it. */
249 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
250 || (XFASTINT (w
->window_end_vpos
) < height
))
256 if (posint
> BUF_ZV (buf
))
259 /* w->start can be out of range. If it is, do something reasonable. */
260 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
263 /* If that info is not correct, calculate afresh */
264 /* BUG FIX for the 7th arg (TOHPOS).
266 '0' is harmless, however, ' - (1 << (BITS_PER_SHORT - 1))' is
267 more appropriate here. In case of HSCROLL > 0, this can avoid
268 needless calculation done until (HPOS == 0).
270 We want to determine if the position POSINT is in HEIGHT or
271 not. We don't have to do calculation until (HPOS == 0). We
272 can stop it when VPOS goes beyond HEIGHT. */
273 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0), 0,
274 posint
, height
, - (1 << (BITS_PER_SHORT
- 1)),
275 window_internal_width (w
) - 1,
278 return posval
.vpos
< height
? Qt
: Qnil
;
282 static struct window
*
283 decode_window (window
)
284 register Lisp_Object window
;
287 return XWINDOW (selected_window
);
289 CHECK_LIVE_WINDOW (window
, 0);
290 return XWINDOW (window
);
293 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
294 "Return the buffer that WINDOW is displaying.")
298 return decode_window (window
)->buffer
;
301 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
302 "Return the number of lines in WINDOW (including its mode line).")
306 return decode_window (window
)->height
;
309 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
310 "Return the number of display columns in WINDOW.\n\
311 This is the width that is usable columns available for text in WINDOW.\n\
312 If you want to find out how many columns WINDOW takes up,\n\
313 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
317 return make_number (window_internal_width (decode_window (window
)));
320 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
321 "Return the number of columns by which WINDOW is scrolled from left margin.")
325 return decode_window (window
)->hscroll
;
328 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
329 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
330 NCOL should be zero or positive.")
332 register Lisp_Object window
, ncol
;
334 register struct window
*w
;
336 CHECK_NUMBER (ncol
, 1);
337 if (XINT (ncol
) < 0) XSETFASTINT (ncol
, 0);
338 w
= decode_window (window
);
339 if (XINT (w
->hscroll
) != XINT (ncol
))
340 XBUFFER (w
->buffer
)->clip_changed
= 1; /* Prevent redisplay shortcuts */
345 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
346 Swindow_redisplay_end_trigger
, 0, 1, 0,
347 "Return WINDOW's redisplay end trigger value.\n\
348 See `set-window-redisplay-end-trigger' for more information.")
352 return decode_window (window
)->redisplay_end_trigger
;
355 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
356 Sset_window_redisplay_end_trigger
, 2, 2, 0,
357 "Set WINDOW's redisplay end trigger value to VALUE.\n\
358 VALUE should be a buffer position (typically a marker) or nil.\n\
359 If it is a buffer position, then if redisplay in WINDOW reaches a position\n\
360 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called\n\
361 with two arguments: WINDOW, and the end trigger value.\n\
362 Afterwards the end-trigger value is reset to nil.")
364 register Lisp_Object window
, value
;
366 register struct window
*w
;
368 w
= decode_window (window
);
369 w
->redisplay_end_trigger
= value
;
373 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
374 "Return a list of the edge coordinates of WINDOW.\n\
375 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
376 RIGHT is one more than the rightmost column used by WINDOW,\n\
377 and BOTTOM is one more than the bottommost row used by WINDOW\n\
382 register struct window
*w
= decode_window (window
);
384 return Fcons (w
->left
, Fcons (w
->top
,
385 Fcons (make_number (WINDOW_RIGHT_EDGE (w
)),
386 Fcons (make_number (XFASTINT (w
->top
)
387 + XFASTINT (w
->height
)),
391 /* Test if the character at column *x, row *y is within window *w.
392 If it is not, return 0;
393 if it is in the window's text area,
394 set *x and *y to its location relative to the upper left corner
397 if it is on the window's modeline, return 2;
398 if it is on the border between the window and its right sibling,
401 coordinates_in_window (w
, x
, y
)
402 register struct window
*w
;
405 register int left
= XINT (w
->left
);
406 register int right_edge
= WINDOW_RIGHT_EDGE (w
);
407 register int left_margin
= WINDOW_LEFT_MARGIN (w
);
408 register int right_margin
= WINDOW_RIGHT_MARGIN (w
);
409 register int window_height
= XINT (w
->height
);
410 register int top
= XFASTINT (w
->top
);
412 if ( *x
< left
|| *x
>= right_edge
413 || *y
< top
|| *y
>= top
+ window_height
)
416 if (left_margin
!= left
&& *x
< left_margin
&& *x
>= left
)
419 if (right_margin
!= right_edge
&& *x
>= right_margin
&& *x
< right_edge
)
422 /* Is the character is the mode line? */
423 if (*y
== top
+ window_height
- 1
424 && ! MINI_WINDOW_P (w
))
427 *x
-= WINDOW_LEFT_MARGIN (w
);
432 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
433 Scoordinates_in_window_p
, 2, 2, 0,
434 "Return non-nil if COORDINATES are in WINDOW.\n\
435 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
436 measured in characters from the upper-left corner of the frame.\n\
437 (0 . 0) denotes the character in the upper left corner of the\n\
439 If COORDINATES are in the text portion of WINDOW,\n\
440 the coordinates relative to the window are returned.\n\
441 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
442 If they are on the border between WINDOW and its right sibling,\n\
443 `vertical-line' is returned.")
444 (coordinates
, window
)
445 register Lisp_Object coordinates
, window
;
449 CHECK_LIVE_WINDOW (window
, 0);
450 CHECK_CONS (coordinates
, 1);
451 x
= XINT (Fcar (coordinates
));
452 y
= XINT (Fcdr (coordinates
));
454 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
456 case 0: /* NOT in window at all. */
459 case 1: /* In text part of window. */
460 return Fcons (make_number (x
), make_number (y
));
462 case 2: /* In mode line of window. */
465 case 3: /* On right border of window. */
466 return Qvertical_line
;
473 /* Find the window containing column x, row y, and return it as a
474 Lisp_Object. If x, y is on the window's modeline, set *part
475 to 1; if it is on the separating line between the window and its
476 right sibling, set it to 2; otherwise set it to 0. If there is no
477 window under x, y return nil and leave *part unmodified. */
479 window_from_coordinates (frame
, x
, y
, part
)
484 register Lisp_Object tem
, first
;
486 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
490 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
498 tem
= Fnext_window (tem
, Qt
, Qlambda
);
500 while (! EQ (tem
, first
));
505 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
506 "Return window containing coordinates X and Y on FRAME.\n\
507 If omitted, FRAME defaults to the currently selected frame.\n\
508 The top left corner of the frame is considered to be row 0,\n\
511 Lisp_Object x
, y
, frame
;
516 XSETFRAME (frame
, selected_frame
);
518 CHECK_LIVE_FRAME (frame
, 2);
522 return window_from_coordinates (XFRAME (frame
),
527 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
528 "Return current value of point in WINDOW.\n\
529 For a nonselected window, this is the value point would have\n\
530 if that window were selected.\n\
532 Note that, when WINDOW is the selected window and its buffer\n\
533 is also currently selected, the value returned is the same as (point).\n\
534 It would be more strictly correct to return the `top-level' value\n\
535 of point, outside of any save-excursion forms.\n\
536 But that is hard to define.")
540 register struct window
*w
= decode_window (window
);
542 if (w
== XWINDOW (selected_window
)
543 && current_buffer
== XBUFFER (w
->buffer
))
545 return Fmarker_position (w
->pointm
);
548 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
549 "Return position at which display currently starts in WINDOW.\n\
550 This is updated by redisplay or by calling `set-window-start'.")
554 return Fmarker_position (decode_window (window
)->start
);
557 /* This is text temporarily removed from the doc string below.
559 This function returns nil if the position is not currently known.\n\
560 That happens when redisplay is preempted and doesn't finish.\n\
561 If in that case you want to compute where the end of the window would\n\
562 have been if redisplay had finished, do this:\n\
564 (goto-char (window-start window))\n\
565 (vertical-motion (1- (window-height window)) window)\n\
568 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
569 "Return position at which display currently ends in WINDOW.\n\
570 This is updated by redisplay, when it runs to completion.\n\
571 Simply changing the buffer text or setting `window-start'\n\
572 does not update this value.")
577 struct window
*w
= decode_window (window
);
581 CHECK_BUFFER (buf
, 0);
583 #if 0 /* This change broke some things. We should make it later. */
584 /* If we don't know the end position, return nil.
585 The user can compute it with vertical-motion if he wants to.
586 It would be nicer to do it automatically,
587 but that's so slow that it would probably bother people. */
588 if (NILP (w
->window_end_valid
))
593 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
598 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
599 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
601 Lisp_Object window
, pos
;
603 register struct window
*w
= decode_window (window
);
605 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
606 if (w
== XWINDOW (selected_window
))
609 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
614 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
615 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
616 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
617 from overriding motion of point in order to display at this exact start.")
618 (window
, pos
, noforce
)
619 Lisp_Object window
, pos
, noforce
;
621 register struct window
*w
= decode_window (window
);
623 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
624 set_marker_restricted (w
->start
, pos
, w
->buffer
);
625 /* this is not right, but much easier than doing what is right. */
626 w
->start_at_line_beg
= Qnil
;
629 w
->update_mode_line
= Qt
;
630 XSETFASTINT (w
->last_modified
, 0);
631 XSETFASTINT (w
->last_overlay_modified
, 0);
632 if (!EQ (window
, selected_window
))
633 windows_or_buffers_changed
++;
637 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
639 "Return WINDOW's dedicated object, usually t or nil.\n\
640 See also `set-window-dedicated-p'.")
644 return decode_window (window
)->dedicated
;
647 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
648 Sset_window_dedicated_p
, 2, 2, 0,
649 "Control whether WINDOW is dedicated to the buffer it displays.\n\
650 If it is dedicated, Emacs will not automatically change\n\
651 which buffer appears in it.\n\
652 The second argument is the new value for the dedication flag;\n\
655 Lisp_Object window
, arg
;
657 register struct window
*w
= decode_window (window
);
667 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
669 "Return the display-table that WINDOW is using.")
673 return decode_window (window
)->display_table
;
676 /* Get the display table for use currently on window W.
677 This is either W's display table or W's buffer's display table.
678 Ignore the specified tables if they are not valid;
679 if no valid table is specified, return 0. */
681 struct Lisp_Char_Table
*
682 window_display_table (w
)
686 tem
= w
->display_table
;
687 if (DISP_TABLE_P (tem
))
688 return XCHAR_TABLE (tem
);
689 tem
= XBUFFER (w
->buffer
)->display_table
;
690 if (DISP_TABLE_P (tem
))
691 return XCHAR_TABLE (tem
);
692 tem
= Vstandard_display_table
;
693 if (DISP_TABLE_P (tem
))
694 return XCHAR_TABLE (tem
);
698 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
699 "Set WINDOW's display-table to TABLE.")
701 register Lisp_Object window
, table
;
703 register struct window
*w
;
704 register Lisp_Object z
; /* Return value. */
706 w
= decode_window (window
);
707 w
->display_table
= table
;
711 /* Record info on buffer window w is displaying
712 when it is about to cease to display that buffer. */
715 register struct window
*w
;
720 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
723 if (w
== XWINDOW (XBUFFER (buf
)->last_selected_window
))
724 XBUFFER (buf
)->last_selected_window
= Qnil
;
727 if (w
== XWINDOW (selected_window
)
728 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
729 /* Do this except when the selected window's buffer
730 is being removed from some other window. */
732 /* last_window_start records the start position that this buffer
733 had in the last window to be disconnected from it.
734 Now that this statement is unconditional,
735 it is possible for the buffer to be displayed in the
736 selected window, while last_window_start reflects another
737 window which was recently showing the same buffer.
738 Some people might say that might be a good thing. Let's see. */
739 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
741 /* Point in the selected window's buffer
742 is actually stored in that buffer, and the window's pointm isn't used.
743 So don't clobber point in that buffer. */
744 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
745 BUF_PT (XBUFFER (buf
))
746 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
747 marker_position (w
->pointm
),
748 BUF_ZV (XBUFFER (buf
)));
751 /* Put replacement into the window structure in place of old. */
753 replace_window (old
, replacement
)
754 Lisp_Object old
, replacement
;
756 register Lisp_Object tem
;
757 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
759 /* If OLD is its frame's root_window, then replacement is the new
760 root_window for that frame. */
762 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
763 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
768 p
->height
= o
->height
;
770 p
->next
= tem
= o
->next
;
772 XWINDOW (tem
)->prev
= replacement
;
774 p
->prev
= tem
= o
->prev
;
776 XWINDOW (tem
)->next
= replacement
;
778 p
->parent
= tem
= o
->parent
;
781 if (EQ (XWINDOW (tem
)->vchild
, old
))
782 XWINDOW (tem
)->vchild
= replacement
;
783 if (EQ (XWINDOW (tem
)->hchild
, old
))
784 XWINDOW (tem
)->hchild
= replacement
;
787 /*** Here, if replacement is a vertical combination
788 and so is its new parent, we should make replacement's
789 children be children of that parent instead. ***/
792 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
793 "Remove WINDOW from the display. Default is selected window.")
795 register Lisp_Object window
;
797 delete_window (window
);
799 if (! NILP (Vwindow_configuration_change_hook
)
800 && ! NILP (Vrun_hooks
))
801 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
806 delete_window (window
)
807 register Lisp_Object window
;
809 register Lisp_Object tem
, parent
, sib
;
810 register struct window
*p
;
811 register struct window
*par
;
813 /* Because this function is called by other C code on non-leaf
814 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
815 so we can't decode_window here. */
817 window
= selected_window
;
819 CHECK_WINDOW (window
, 0);
820 p
= XWINDOW (window
);
822 /* It's okay to delete an already-deleted window. */
830 error ("Attempt to delete minibuffer or sole ordinary window");
831 par
= XWINDOW (parent
);
833 windows_or_buffers_changed
++;
834 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (p
))) = 1;
836 /* Are we trying to delete any frame's selected window? */
838 Lisp_Object frame
, pwindow
;
840 /* See if the frame's selected window is either WINDOW
841 or any subwindow of it, by finding all that window's parents
842 and comparing each one with WINDOW. */
843 frame
= WINDOW_FRAME (XWINDOW (window
));
844 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
846 while (!NILP (pwindow
))
848 if (EQ (window
, pwindow
))
850 pwindow
= XWINDOW (pwindow
)->parent
;
853 if (EQ (window
, pwindow
))
855 Lisp_Object alternative
;
856 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
858 /* If we're about to delete the selected window on the
859 selected frame, then we should use Fselect_window to select
860 the new window. On the other hand, if we're about to
861 delete the selected window on any other frame, we shouldn't do
862 anything but set the frame's selected_window slot. */
863 if (EQ (window
, selected_window
))
864 Fselect_window (alternative
);
866 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
871 /* tem is null for dummy parent windows
872 (which have inferiors but not any contents themselves) */
876 unchain_marker (p
->pointm
);
877 unchain_marker (p
->start
);
882 XWINDOW (tem
)->prev
= p
->prev
;
886 XWINDOW (tem
)->next
= p
->next
;
888 if (EQ (window
, par
->hchild
))
889 par
->hchild
= p
->next
;
890 if (EQ (window
, par
->vchild
))
891 par
->vchild
= p
->next
;
893 /* Find one of our siblings to give our space to. */
897 /* If p gives its space to its next sibling, that sibling needs
898 to have its top/left side pulled back to where p's is.
899 set_window_{height,width} will re-position the sibling's
902 XWINDOW (sib
)->top
= p
->top
;
903 XWINDOW (sib
)->left
= p
->left
;
906 /* Stretch that sibling. */
907 if (!NILP (par
->vchild
))
908 set_window_height (sib
,
909 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
911 if (!NILP (par
->hchild
))
912 set_window_width (sib
,
913 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
916 /* If parent now has only one child,
917 put the child into the parent's place. */
921 if (NILP (XWINDOW (tem
)->next
))
922 replace_window (parent
, tem
);
924 /* Since we may be deleting combination windows, we must make sure that
925 not only p but all its children have been marked as deleted. */
926 if (! NILP (p
->hchild
))
927 delete_all_subwindows (XWINDOW (p
->hchild
));
928 else if (! NILP (p
->vchild
))
929 delete_all_subwindows (XWINDOW (p
->vchild
));
931 /* Mark this window as deleted. */
932 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
936 extern Lisp_Object
next_frame (), prev_frame ();
938 /* This comment supplies the doc string for `next-window',
939 for make-docfile to see. We cannot put this in the real DEFUN
940 due to limits in the Unix cpp.
942 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
943 "Return next window after WINDOW in canonical ordering of windows.\n\
944 If omitted, WINDOW defaults to the selected window.\n\
946 Optional second arg MINIBUF t means count the minibuffer window even\n\
947 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
948 it is active. MINIBUF neither t nor nil means not to count the\n\
949 minibuffer even if it is active.\n\
951 Several frames may share a single minibuffer; if the minibuffer\n\
952 counts, all windows on all frames that share that minibuffer count\n\
953 too. Therefore, `next-window' can be used to iterate through the\n\
954 set of windows even when the minibuffer is on another frame. If the\n\
955 minibuffer does not count, only windows from WINDOW's frame count.\n\
957 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
958 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
959 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
960 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
961 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
962 Anything else means restrict to WINDOW's frame.\n\
964 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
965 `next-window' to iterate through the entire cycle of acceptable\n\
966 windows, eventually ending up back at the window you started with.\n\
967 `previous-window' traverses the same cycle, in the reverse order.")
968 (window, minibuf, all_frames) */
970 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
972 (window
, minibuf
, all_frames
)
973 register Lisp_Object window
, minibuf
, all_frames
;
975 register Lisp_Object tem
;
976 Lisp_Object start_window
;
979 window
= selected_window
;
981 CHECK_LIVE_WINDOW (window
, 0);
983 start_window
= window
;
985 /* minibuf == nil may or may not include minibuffers.
986 Decide if it does. */
988 minibuf
= (minibuf_level
? minibuf_window
: Qlambda
);
989 else if (! EQ (minibuf
, Qt
))
991 /* Now minibuf can be t => count all minibuffer windows,
992 lambda => count none of them,
993 or a specific minibuffer window (the active one) to count. */
995 /* all_frames == nil doesn't specify which frames to include. */
996 if (NILP (all_frames
))
997 all_frames
= (! EQ (minibuf
, Qlambda
)
998 ? (FRAME_MINIBUF_WINDOW
1001 (XWINDOW (window
)))))
1003 else if (EQ (all_frames
, Qvisible
))
1005 else if (XFASTINT (all_frames
) == 0)
1007 else if (FRAMEP (all_frames
) && ! EQ (all_frames
, Fwindow_frame (window
)))
1008 /* If all_frames is a frame and window arg isn't on that frame, just
1009 return the first window on the frame. */
1010 return Fframe_first_window (all_frames
);
1011 else if (! EQ (all_frames
, Qt
))
1013 /* Now all_frames is t meaning search all frames,
1014 nil meaning search just current frame,
1015 visible meaning search just visible frames,
1016 0 meaning search visible and iconified frames,
1017 or a window, meaning search the frame that window belongs to. */
1019 /* Do this loop at least once, to get the next window, and perhaps
1020 again, if we hit the minibuffer and that is not acceptable. */
1023 /* Find a window that actually has a next one. This loop
1024 climbs up the tree. */
1025 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
1026 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1030 /* We've reached the end of this frame.
1031 Which other frames are acceptable? */
1032 tem
= WINDOW_FRAME (XWINDOW (window
));
1033 if (! NILP (all_frames
))
1038 tem
= next_frame (tem
, all_frames
);
1039 /* In the case where the minibuffer is active,
1040 and we include its frame as well as the selected one,
1041 next_frame may get stuck in that frame.
1042 If that happens, go back to the selected frame
1043 so we can complete the cycle. */
1045 XSETFRAME (tem
, selected_frame
);
1047 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1054 /* If we're in a combination window, find its first child and
1055 recurse on that. Otherwise, we've found the window we want. */
1058 if (!NILP (XWINDOW (window
)->hchild
))
1059 window
= XWINDOW (window
)->hchild
;
1060 else if (!NILP (XWINDOW (window
)->vchild
))
1061 window
= XWINDOW (window
)->vchild
;
1065 /* Which windows are acceptable?
1066 Exit the loop and accept this window if
1067 this isn't a minibuffer window,
1068 or we're accepting all minibuffer windows,
1069 or this is the active minibuffer and we are accepting that one, or
1070 we've come all the way around and we're back at the original window. */
1071 while (MINI_WINDOW_P (XWINDOW (window
))
1072 && ! EQ (minibuf
, Qt
)
1073 && ! EQ (minibuf
, window
)
1074 && ! EQ (window
, start_window
));
1079 /* This comment supplies the doc string for `previous-window',
1080 for make-docfile to see. We cannot put this in the real DEFUN
1081 due to limits in the Unix cpp.
1083 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
1084 "Return the window preceding WINDOW in canonical ordering of windows.\n\
1085 If omitted, WINDOW defaults to the selected window.\n\
1087 Optional second arg MINIBUF t means count the minibuffer window even\n\
1088 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1089 it is active. MINIBUF neither t nor nil means not to count the\n\
1090 minibuffer even if it is active.\n\
1092 Several frames may share a single minibuffer; if the minibuffer\n\
1093 counts, all windows on all frames that share that minibuffer count\n\
1094 too. Therefore, `previous-window' can be used to iterate through\n\
1095 the set of windows even when the minibuffer is on another frame. If\n\
1096 the minibuffer does not count, only windows from WINDOW's frame count\n\
1098 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1099 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1100 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1101 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1102 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
1103 Anything else means restrict to WINDOW's frame.\n\
1105 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1106 `previous-window' to iterate through the entire cycle of acceptable\n\
1107 windows, eventually ending up back at the window you started with.\n\
1108 `next-window' traverses the same cycle, in the reverse order.")
1109 (window, minibuf, all_frames) */
1112 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1114 (window
, minibuf
, all_frames
)
1115 register Lisp_Object window
, minibuf
, all_frames
;
1117 register Lisp_Object tem
;
1118 Lisp_Object start_window
;
1121 window
= selected_window
;
1123 CHECK_LIVE_WINDOW (window
, 0);
1125 start_window
= window
;
1127 /* minibuf == nil may or may not include minibuffers.
1128 Decide if it does. */
1130 minibuf
= (minibuf_level
? minibuf_window
: Qlambda
);
1131 else if (! EQ (minibuf
, Qt
))
1133 /* Now minibuf can be t => count all minibuffer windows,
1134 lambda => count none of them,
1135 or a specific minibuffer window (the active one) to count. */
1137 /* all_frames == nil doesn't specify which frames to include.
1138 Decide which frames it includes. */
1139 if (NILP (all_frames
))
1140 all_frames
= (! EQ (minibuf
, Qlambda
)
1141 ? (FRAME_MINIBUF_WINDOW
1144 (XWINDOW (window
)))))
1146 else if (EQ (all_frames
, Qvisible
))
1148 else if (XFASTINT (all_frames
) == 0)
1150 else if (FRAMEP (all_frames
) && ! EQ (all_frames
, Fwindow_frame (window
)))
1151 /* If all_frames is a frame and window arg isn't on that frame, just
1152 return the first window on the frame. */
1153 return Fframe_first_window (all_frames
);
1154 else if (! EQ (all_frames
, Qt
))
1156 /* Now all_frames is t meaning search all frames,
1157 nil meaning search just current frame,
1158 visible meaning search just visible frames,
1159 0 meaning search visible and iconified frames,
1160 or a window, meaning search the frame that window belongs to. */
1162 /* Do this loop at least once, to get the previous window, and perhaps
1163 again, if we hit the minibuffer and that is not acceptable. */
1166 /* Find a window that actually has a previous one. This loop
1167 climbs up the tree. */
1168 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1169 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1173 /* We have found the top window on the frame.
1174 Which frames are acceptable? */
1175 tem
= WINDOW_FRAME (XWINDOW (window
));
1176 if (! NILP (all_frames
))
1177 /* It's actually important that we use prev_frame here,
1178 rather than next_frame. All the windows acceptable
1179 according to the given parameters should form a ring;
1180 Fnext_window and Fprevious_window should go back and
1181 forth around the ring. If we use next_frame here,
1182 then Fnext_window and Fprevious_window take different
1183 paths through the set of acceptable windows.
1184 window_loop assumes that these `ring' requirement are
1190 tem
= prev_frame (tem
, all_frames
);
1191 /* In the case where the minibuffer is active,
1192 and we include its frame as well as the selected one,
1193 next_frame may get stuck in that frame.
1194 If that happens, go back to the selected frame
1195 so we can complete the cycle. */
1197 XSETFRAME (tem
, selected_frame
);
1199 /* If this frame has a minibuffer, find that window first,
1200 because it is conceptually the last window in that frame. */
1201 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1202 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1204 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1210 /* If we're in a combination window, find its last child and
1211 recurse on that. Otherwise, we've found the window we want. */
1214 if (!NILP (XWINDOW (window
)->hchild
))
1215 window
= XWINDOW (window
)->hchild
;
1216 else if (!NILP (XWINDOW (window
)->vchild
))
1217 window
= XWINDOW (window
)->vchild
;
1219 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1223 /* Which windows are acceptable?
1224 Exit the loop and accept this window if
1225 this isn't a minibuffer window,
1226 or we're accepting all minibuffer windows,
1227 or this is the active minibuffer and we are accepting that one, or
1228 we've come all the way around and we're back at the original window. */
1229 while (MINI_WINDOW_P (XWINDOW (window
))
1230 && ! EQ (minibuf
, Qt
)
1231 && ! EQ (minibuf
, window
)
1232 && ! EQ (window
, start_window
));
1237 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1238 "Select the ARG'th different window on this frame.\n\
1239 All windows on current frame are arranged in a cyclic order.\n\
1240 This command selects the window ARG steps away in that order.\n\
1241 A negative ARG moves in the opposite order. If the optional second\n\
1242 argument ALL_FRAMES is non-nil, cycle through all frames.")
1244 register Lisp_Object arg
, all_frames
;
1247 register Lisp_Object w
;
1249 CHECK_NUMBER (arg
, 0);
1250 w
= selected_window
;
1255 w
= Fnext_window (w
, Qnil
, all_frames
);
1260 w
= Fprevious_window (w
, Qnil
, all_frames
);
1267 /* Look at all windows, performing an operation specified by TYPE
1269 If FRAMES is Qt, look at all frames;
1270 Qnil, look at just the selected frame;
1271 Qvisible, look at visible frames;
1272 a frame, just look at windows on that frame.
1273 If MINI is non-zero, perform the operation on minibuffer windows too.
1279 GET_BUFFER_WINDOW
, /* Arg is buffer */
1280 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1281 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1282 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1284 UNSHOW_BUFFER
/* Arg is buffer */
1288 window_loop (type
, obj
, mini
, frames
)
1289 enum window_loop type
;
1290 register Lisp_Object obj
, frames
;
1293 register Lisp_Object w
;
1294 register Lisp_Object best_window
;
1295 register Lisp_Object next_window
;
1296 register Lisp_Object last_window
;
1298 Lisp_Object frame_arg
;
1301 /* If we're only looping through windows on a particular frame,
1302 frame points to that frame. If we're looping through windows
1303 on all frames, frame is 0. */
1304 if (FRAMEP (frames
))
1305 frame
= XFRAME (frames
);
1306 else if (NILP (frames
))
1307 frame
= selected_frame
;
1311 frame_arg
= Qlambda
;
1312 else if (XFASTINT (frames
) == 0)
1314 else if (EQ (frames
, Qvisible
))
1317 /* frame_arg is Qlambda to stick to one frame,
1318 Qvisible to consider all visible frames,
1321 /* Pick a window to start with. */
1325 w
= FRAME_SELECTED_WINDOW (frame
);
1327 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1329 /* Figure out the last window we're going to mess with. Since
1330 Fnext_window, given the same options, is guaranteed to go in a
1331 ring, we can just use Fprevious_window to find the last one.
1333 We can't just wait until we hit the first window again, because
1334 it might be deleted. */
1336 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1341 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1343 /* Pick the next window now, since some operations will delete
1344 the current window. */
1345 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1347 /* Note that we do not pay attention here to whether
1348 the frame is visible, since Fnext_window skips non-visible frames
1349 if that is desired, under the control of frame_arg. */
1350 if (! MINI_WINDOW_P (XWINDOW (w
))
1351 || (mini
&& minibuf_level
> 0))
1354 case GET_BUFFER_WINDOW
:
1355 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
)
1356 /* Don't find any minibuffer window
1357 except the one that is currently in use. */
1358 && (MINI_WINDOW_P (XWINDOW (w
))
1359 ? EQ (w
, minibuf_window
) : 1))
1363 case GET_LRU_WINDOW
:
1364 /* t as arg means consider only full-width windows */
1365 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (XWINDOW (w
)))
1367 /* Ignore dedicated windows and minibuffers. */
1368 if (MINI_WINDOW_P (XWINDOW (w
))
1369 || !NILP (XWINDOW (w
)->dedicated
))
1371 if (NILP (best_window
)
1372 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1373 > XFASTINT (XWINDOW (w
)->use_time
)))
1377 case DELETE_OTHER_WINDOWS
:
1378 if (XWINDOW (w
) != XWINDOW (obj
))
1382 case DELETE_BUFFER_WINDOWS
:
1383 if (EQ (XWINDOW (w
)->buffer
, obj
))
1385 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1387 /* If this window is dedicated, and in a frame of its own,
1389 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1390 && !NILP (XWINDOW (w
)->dedicated
)
1391 && other_visible_frames (f
))
1393 /* Skip the other windows on this frame.
1394 There might be one, the minibuffer! */
1395 if (! EQ (w
, last_window
))
1396 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1398 /* As we go, check for the end of the loop.
1399 We mustn't start going around a second time. */
1400 if (EQ (next_window
, last_window
))
1405 next_window
= Fnext_window (next_window
,
1409 /* Now we can safely delete the frame. */
1410 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1413 /* If we're deleting the buffer displayed in the only window
1414 on the frame, find a new buffer to display there. */
1415 if (NILP (XWINDOW (w
)->parent
))
1417 Lisp_Object new_buffer
;
1418 new_buffer
= Fother_buffer (obj
, Qnil
);
1419 if (NILP (new_buffer
))
1421 = Fget_buffer_create (build_string ("*scratch*"));
1422 Fset_window_buffer (w
, new_buffer
);
1423 if (EQ (w
, selected_window
))
1424 Fset_buffer (XWINDOW (w
)->buffer
);
1431 case GET_LARGEST_WINDOW
:
1432 /* Ignore dedicated windows and minibuffers. */
1433 if (MINI_WINDOW_P (XWINDOW (w
))
1434 || !NILP (XWINDOW (w
)->dedicated
))
1437 struct window
*best_window_ptr
= XWINDOW (best_window
);
1438 struct window
*w_ptr
= XWINDOW (w
);
1439 if (NILP (best_window
)
1440 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1441 > (XFASTINT (best_window_ptr
->height
)
1442 * XFASTINT (best_window_ptr
->width
))))
1448 if (EQ (XWINDOW (w
)->buffer
, obj
))
1450 /* Find another buffer to show in this window. */
1451 Lisp_Object another_buffer
;
1452 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1453 another_buffer
= Fother_buffer (obj
, Qnil
);
1454 if (NILP (another_buffer
))
1456 = Fget_buffer_create (build_string ("*scratch*"));
1457 /* If this window is dedicated, and in a frame of its own,
1459 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1460 && !NILP (XWINDOW (w
)->dedicated
)
1461 && other_visible_frames (f
))
1463 /* Skip the other windows on this frame.
1464 There might be one, the minibuffer! */
1465 if (! EQ (w
, last_window
))
1466 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1468 /* As we go, check for the end of the loop.
1469 We mustn't start going around a second time. */
1470 if (EQ (next_window
, last_window
))
1475 next_window
= Fnext_window (next_window
,
1479 /* Now we can safely delete the frame. */
1480 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1484 /* Otherwise show a different buffer in the window. */
1485 XWINDOW (w
)->dedicated
= Qnil
;
1486 Fset_window_buffer (w
, another_buffer
);
1487 if (EQ (w
, selected_window
))
1488 Fset_buffer (XWINDOW (w
)->buffer
);
1494 if (EQ (w
, last_window
))
1503 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1504 "Return the window least recently selected or used for display.\n\
1505 If optional argument FRAME is `visible', search all visible frames.\n\
1506 If FRAME is 0, search all visible and iconified frames.\n\
1507 If FRAME is t, search all frames.\n\
1508 If FRAME is nil, search only the selected frame.\n\
1509 If FRAME is a frame, search only that frame.")
1513 register Lisp_Object w
;
1514 /* First try for a window that is full-width */
1515 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1516 if (!NILP (w
) && !EQ (w
, selected_window
))
1518 /* If none of them, try the rest */
1519 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1522 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1523 "Return the largest window in area.\n\
1524 If optional argument FRAME is `visible', search all visible frames.\n\
1525 If FRAME is 0, search all visible and iconified frames.\n\
1526 If FRAME is t, search all frames.\n\
1527 If FRAME is nil, search only the selected frame.\n\
1528 If FRAME is a frame, search only that frame.")
1532 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1536 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1537 "Return a window currently displaying BUFFER, or nil if none.\n\
1538 If optional argument FRAME is `visible', search all visible frames.\n\
1539 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1540 If FRAME is t, search all frames.\n\
1541 If FRAME is nil, search only the selected frame.\n\
1542 If FRAME is a frame, search only that frame.")
1544 Lisp_Object buffer
, frame
;
1546 buffer
= Fget_buffer (buffer
);
1547 if (BUFFERP (buffer
))
1548 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1553 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1555 "Make WINDOW (or the selected window) fill its frame.\n\
1556 Only the frame WINDOW is on is affected.\n\
1557 This function tries to reduce display jumps\n\
1558 by keeping the text previously visible in WINDOW\n\
1559 in the same place on the frame. Doing this depends on\n\
1560 the value of (window-start WINDOW), so if calling this function\n\
1561 in a program gives strange scrolling, make sure the window-start\n\
1562 value is reasonable when this function is called.")
1571 window
= selected_window
;
1573 CHECK_LIVE_WINDOW (window
, 0);
1575 w
= XWINDOW (window
);
1577 startpos
= marker_position (w
->start
);
1578 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1580 if (MINI_WINDOW_P (w
) && top
> 0)
1581 error ("Can't expand minibuffer to full frame");
1583 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1585 /* Try to minimize scrolling, by setting the window start to the point
1586 will cause the text at the old window start to be at the same place
1587 on the frame. But don't try to do this if the window start is
1588 outside the visible portion (as might happen when the display is
1589 not current, due to typeahead). */
1590 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1591 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1593 struct position pos
;
1594 struct buffer
*obuf
= current_buffer
;
1596 Fset_buffer (w
->buffer
);
1597 /* This computation used to temporarily move point, but that can
1598 have unwanted side effects due to text properties. */
1599 pos
= *vmotion (startpos
, -top
, w
);
1601 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1602 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1603 || FETCH_BYTE (pos
.bufpos
- 1) == '\n') ? Qt
1605 /* We need to do this, so that the window-scroll-functions
1607 w
->optional_new_start
= Qt
;
1609 set_buffer_internal (obuf
);
1614 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1615 1, 2, "bDelete windows on (buffer): ",
1616 "Delete all windows showing BUFFER.\n\
1617 Optional second argument FRAME controls which frames are affected.\n\
1618 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1619 If t, delete only windows showing BUFFER in the selected frame.\n\
1620 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1621 If a frame, delete only windows showing BUFFER in that frame.")
1623 Lisp_Object buffer
, frame
;
1625 /* FRAME uses t and nil to mean the opposite of what window_loop
1627 if (! FRAMEP (frame
))
1628 frame
= NILP (frame
) ? Qt
: Qnil
;
1632 buffer
= Fget_buffer (buffer
);
1633 CHECK_BUFFER (buffer
, 0);
1634 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1639 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1640 Sreplace_buffer_in_windows
,
1641 1, 1, "bReplace buffer in windows: ",
1642 "Replace BUFFER with some other buffer in all windows showing it.")
1648 buffer
= Fget_buffer (buffer
);
1649 CHECK_BUFFER (buffer
, 0);
1650 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1655 /* Replace BUFFER with some other buffer in all windows
1656 of all frames, even those on other keyboards. */
1659 replace_buffer_in_all_windows (buffer
)
1663 Lisp_Object tail
, frame
;
1665 /* A single call to window_loop won't do the job
1666 because it only considers frames on the current keyboard.
1667 So loop manually over frames, and handle each one. */
1668 FOR_EACH_FRAME (tail
, frame
)
1669 window_loop (UNSHOW_BUFFER
, buffer
, 0, frame
);
1671 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1675 /* Set the height of WINDOW and all its inferiors. */
1677 /* The smallest acceptable dimensions for a window. Anything smaller
1678 might crash Emacs. */
1679 #define MIN_SAFE_WINDOW_WIDTH (2)
1680 #define MIN_SAFE_WINDOW_HEIGHT (2)
1682 /* Make sure that window_min_height and window_min_width are
1683 not too small; if they are, set them to safe minima. */
1686 check_min_window_sizes ()
1688 /* Smaller values might permit a crash. */
1689 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1690 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1691 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1692 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1695 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1696 minimum allowable size. */
1698 check_frame_size (frame
, rows
, cols
)
1702 /* For height, we have to see:
1703 whether the frame has a minibuffer,
1704 whether it wants a mode line, and
1705 whether it has a menu bar. */
1707 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1708 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1709 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1710 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1711 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1713 if (*rows
< min_height
)
1715 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1716 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1719 /* Normally the window is deleted if it gets too small.
1720 nodelete nonzero means do not do this.
1721 (The caller should check later and do so if appropriate) */
1723 set_window_height (window
, height
, nodelete
)
1728 register struct window
*w
= XWINDOW (window
);
1729 register struct window
*c
;
1730 int oheight
= XFASTINT (w
->height
);
1731 int top
, pos
, lastbot
, opos
, lastobot
;
1734 check_min_window_sizes ();
1737 && ! NILP (w
->parent
)
1738 && (MINI_WINDOW_P (w
)
1740 : height
< window_min_height
))
1742 delete_window (window
);
1746 XSETFASTINT (w
->last_modified
, 0);
1747 XSETFASTINT (w
->last_overlay_modified
, 0);
1748 windows_or_buffers_changed
++;
1749 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1751 XSETFASTINT (w
->height
, height
);
1752 if (!NILP (w
->hchild
))
1754 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1756 XWINDOW (child
)->top
= w
->top
;
1757 set_window_height (child
, height
, nodelete
);
1760 else if (!NILP (w
->vchild
))
1762 lastbot
= top
= XFASTINT (w
->top
);
1764 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1766 c
= XWINDOW (child
);
1768 opos
= lastobot
+ XFASTINT (c
->height
);
1770 XSETFASTINT (c
->top
, lastbot
);
1772 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1774 /* Avoid confusion: inhibit deletion of child if becomes too small */
1775 set_window_height (child
, pos
+ top
- lastbot
, 1);
1777 /* Now advance child to next window,
1778 and set lastbot if child was not just deleted. */
1779 lastbot
= pos
+ top
;
1782 /* Now delete any children that became too small. */
1784 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1786 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1791 /* Recursively set width of WINDOW and its inferiors. */
1793 set_window_width (window
, width
, nodelete
)
1798 register struct window
*w
= XWINDOW (window
);
1799 register struct window
*c
;
1800 int owidth
= XFASTINT (w
->width
);
1801 int left
, pos
, lastright
, opos
, lastoright
;
1804 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1806 delete_window (window
);
1810 XSETFASTINT (w
->last_modified
, 0);
1811 XSETFASTINT (w
->last_overlay_modified
, 0);
1812 windows_or_buffers_changed
++;
1813 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
1815 XSETFASTINT (w
->width
, width
);
1816 if (!NILP (w
->vchild
))
1818 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1820 XWINDOW (child
)->left
= w
->left
;
1821 set_window_width (child
, width
, nodelete
);
1824 else if (!NILP (w
->hchild
))
1826 lastright
= left
= XFASTINT (w
->left
);
1828 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1830 c
= XWINDOW (child
);
1832 opos
= lastoright
+ XFASTINT (c
->width
);
1834 XSETFASTINT (c
->left
, lastright
);
1836 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1838 /* Inhibit deletion for becoming too small */
1839 set_window_width (child
, pos
+ left
- lastright
, 1);
1841 /* Now advance child to next window,
1842 and set lastright if child was not just deleted. */
1843 lastright
= pos
+ left
, lastoright
= opos
;
1845 /* Delete children that became too small */
1847 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1849 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1854 int window_select_count
;
1857 Fset_window_buffer_unwind (obuf
)
1864 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1865 "Make WINDOW display BUFFER as its contents.\n\
1866 BUFFER can be a buffer or buffer name.")
1868 register Lisp_Object window
, buffer
;
1870 register Lisp_Object tem
;
1871 register struct window
*w
= decode_window (window
);
1872 int count
= specpdl_ptr
- specpdl
;
1874 buffer
= Fget_buffer (buffer
);
1875 CHECK_BUFFER (buffer
, 1);
1877 if (NILP (XBUFFER (buffer
)->name
))
1878 error ("Attempt to display deleted buffer");
1882 error ("Window is deleted");
1883 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1884 is first being set up. */
1886 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1887 error ("Window is dedicated to `%s'",
1888 XSTRING (XBUFFER (tem
)->name
)->data
);
1895 if (EQ (window
, selected_window
))
1896 XBUFFER (w
->buffer
)->last_selected_window
= window
;
1897 if (INTEGERP (XBUFFER (buffer
)->display_count
))
1898 XSETINT (XBUFFER (buffer
)->display_count
,
1899 XINT (XBUFFER (buffer
)->display_count
) + 1);
1901 XSETFASTINT (w
->window_end_pos
, 0);
1902 w
->window_end_valid
= Qnil
;
1903 XSETFASTINT (w
->hscroll
, 0);
1904 Fset_marker (w
->pointm
,
1905 make_number (BUF_PT (XBUFFER (buffer
))),
1907 set_marker_restricted (w
->start
,
1908 make_number (XBUFFER (buffer
)->last_window_start
),
1910 w
->start_at_line_beg
= Qnil
;
1911 w
->force_start
= Qnil
;
1912 XSETFASTINT (w
->last_modified
, 0);
1913 XSETFASTINT (w
->last_overlay_modified
, 0);
1914 windows_or_buffers_changed
++;
1916 /* We must select BUFFER for running the window-scroll-functions.
1917 If WINDOW is selected, switch permanently.
1918 Otherwise, switch but go back to the ambient buffer afterward. */
1919 if (EQ (window
, selected_window
))
1920 Fset_buffer (buffer
);
1921 /* We can't check ! NILP (Vwindow_scroll_functions) here
1922 because that might itself be a local variable. */
1923 else if (window_initialized
)
1925 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
1926 Fset_buffer (buffer
);
1929 if (! NILP (Vwindow_scroll_functions
))
1930 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1931 Fmarker_position (w
->start
));
1933 if (! NILP (Vwindow_configuration_change_hook
)
1934 && ! NILP (Vrun_hooks
))
1935 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1937 unbind_to (count
, Qnil
);
1942 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1943 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1944 The main editor command loop selects the buffer of the selected window\n\
1945 before each command.")
1947 register Lisp_Object window
;
1949 register struct window
*w
;
1950 register struct window
*ow
= XWINDOW (selected_window
);
1952 CHECK_LIVE_WINDOW (window
, 0);
1954 w
= XWINDOW (window
);
1956 if (NILP (w
->buffer
))
1957 error ("Trying to select deleted window or non-leaf window");
1959 XSETFASTINT (w
->use_time
, ++window_select_count
);
1960 if (EQ (window
, selected_window
))
1963 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1966 selected_window
= window
;
1967 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1969 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1970 /* Use this rather than Fhandle_switch_frame
1971 so that FRAME_FOCUS_FRAME is moved appropriately as we
1972 move around in the state where a minibuffer in a separate
1974 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1977 selected_frame
->selected_window
= window
;
1979 record_buffer (w
->buffer
);
1980 Fset_buffer (w
->buffer
);
1982 XBUFFER (w
->buffer
)->last_selected_window
= window
;
1984 /* Go to the point recorded in the window.
1985 This is important when the buffer is in more
1986 than one window. It also matters when
1987 redisplay_window has altered point after scrolling,
1988 because it makes the change only in the window. */
1990 register int new_point
= marker_position (w
->pointm
);
1991 if (new_point
< BEGV
)
1993 else if (new_point
> ZV
)
1999 windows_or_buffers_changed
++;
2003 /* Deiconify the frame containing the window WINDOW,
2004 unless it is the selected frame;
2007 The reason for the exception for the selected frame
2008 is that it seems better not to change the selected frames visibility
2009 merely because of displaying a different buffer in it.
2010 The deiconification is useful when a buffer gets shown in
2011 another frame that you were not using lately. */
2014 display_buffer_1 (window
)
2017 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
2018 FRAME_SAMPLE_VISIBILITY (f
);
2019 if (f
!= selected_frame
)
2021 if (FRAME_ICONIFIED_P (f
))
2022 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2023 else if (FRAME_VISIBLE_P (f
))
2024 Fraise_frame (WINDOW_FRAME (XWINDOW (window
)));
2029 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
2030 "Returns non-nil if a buffer named BUFFER-NAME would be created specially.\n\
2031 The value is actually t if the frame should be called with default frame\n\
2032 parameters, and a list of frame parameters if they were specified.\n\
2033 See `special-display-buffer-names', and `special-display-regexps'.")
2035 Lisp_Object buffer_name
;
2039 CHECK_STRING (buffer_name
, 1);
2041 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
2045 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
2049 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2051 Lisp_Object car
= XCAR (tem
);
2053 && fast_string_match (car
, buffer_name
) >= 0)
2055 else if (CONSP (car
)
2056 && STRINGP (XCAR (car
))
2057 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2063 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
2064 "Returns non-nil if a new buffer named BUFFER-NAME would use the same window.\n\
2065 See `same-window-buffer-names' and `same-window-regexps'.")
2067 Lisp_Object buffer_name
;
2071 CHECK_STRING (buffer_name
, 1);
2073 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
2077 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
2081 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2083 Lisp_Object car
= XCAR (tem
);
2085 && fast_string_match (car
, buffer_name
) >= 0)
2087 else if (CONSP (car
)
2088 && STRINGP (XCAR (car
))
2089 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2095 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
2096 "BDisplay buffer: \nP", /* Use B so the default is (other-buffer). */
2097 "Make BUFFER appear in some window but don't select it.\n\
2098 BUFFER can be a buffer or a buffer name.\n\
2099 If BUFFER is shown already in some window, just use that one,\n\
2100 unless the window is the selected window and the optional second\n\
2101 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
2102 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
2103 Returns the window displaying BUFFER.\n\
2105 The variables `special-display-buffer-names', `special-display-regexps',\n\
2106 `same-window-buffer-names', and `same-window-regexps' customize how certain\n\
2107 buffer names are handled.")
2108 (buffer
, not_this_window
)
2109 register Lisp_Object buffer
, not_this_window
;
2111 register Lisp_Object window
, tem
;
2113 buffer
= Fget_buffer (buffer
);
2114 CHECK_BUFFER (buffer
, 0);
2116 if (!NILP (Vdisplay_buffer_function
))
2117 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
2119 if (NILP (not_this_window
)
2120 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
2121 return display_buffer_1 (selected_window
);
2123 /* See if the user has specified this buffer should appear
2124 in the selected window. */
2125 if (NILP (not_this_window
))
2127 tem
= Fsame_window_p (XBUFFER (buffer
)->name
);
2130 Fswitch_to_buffer (buffer
, Qnil
);
2131 return display_buffer_1 (selected_window
);
2135 /* If pop_up_frames,
2136 look for a window showing BUFFER on any visible or iconified frame.
2137 Otherwise search only the current frame. */
2138 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
2139 XSETFASTINT (tem
, 0);
2141 XSETFRAME (tem
, last_nonminibuf_frame
);
2142 window
= Fget_buffer_window (buffer
, tem
);
2144 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
2146 return display_buffer_1 (window
);
2149 /* Certain buffer names get special handling. */
2150 if (!NILP (Vspecial_display_function
))
2152 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
2154 return call1 (Vspecial_display_function
, buffer
);
2156 return call2 (Vspecial_display_function
, buffer
, tem
);
2159 /* If there are no frames open that have more than a minibuffer,
2160 we need to create a new frame. */
2161 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
2163 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2164 Fset_window_buffer (window
, buffer
);
2165 return display_buffer_1 (window
);
2169 || FRAME_MINIBUF_ONLY_P (selected_frame
)
2170 /* If the current frame is a special display frame,
2171 don't try to reuse its windows. */
2172 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
2178 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
2179 XSETFRAME (frames
, last_nonminibuf_frame
);
2180 /* Don't try to create a window if would get an error */
2181 if (split_height_threshold
< window_min_height
<< 1)
2182 split_height_threshold
= window_min_height
<< 1;
2184 /* Note that both Fget_largest_window and Fget_lru_window
2185 ignore minibuffers and dedicated windows.
2186 This means they can return nil. */
2188 /* If the frame we would try to split cannot be split,
2189 try other frames. */
2190 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
2191 : last_nonminibuf_frame
))
2193 /* Try visible frames first. */
2194 window
= Fget_largest_window (Qvisible
);
2195 /* If that didn't work, try iconified frames. */
2197 window
= Fget_largest_window (make_number (0));
2199 window
= Fget_largest_window (Qt
);
2202 window
= Fget_largest_window (frames
);
2204 /* If we got a tall enough full-width window that can be split,
2207 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2208 && window_height (window
) >= split_height_threshold
2209 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
2210 window
= Fsplit_window (window
, Qnil
, Qnil
);
2213 Lisp_Object upper
, lower
, other
;
2215 window
= Fget_lru_window (frames
);
2216 /* If the LRU window is selected, and big enough,
2217 and can be split, split it. */
2219 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2220 && (EQ (window
, selected_window
)
2221 || EQ (XWINDOW (window
)->parent
, Qnil
))
2222 && window_height (window
) >= window_min_height
<< 1)
2223 window
= Fsplit_window (window
, Qnil
, Qnil
);
2224 /* If Fget_lru_window returned nil, try other approaches. */
2226 /* Try visible frames first. */
2228 window
= Fget_buffer_window (buffer
, Qvisible
);
2230 window
= Fget_largest_window (Qvisible
);
2231 /* If that didn't work, try iconified frames. */
2233 window
= Fget_buffer_window (buffer
, make_number (0));
2235 window
= Fget_largest_window (make_number (0));
2236 /* Try invisible frames. */
2238 window
= Fget_buffer_window (buffer
, Qt
);
2240 window
= Fget_largest_window (Qt
);
2241 /* As a last resort, make a new frame. */
2243 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2244 /* If window appears above or below another,
2245 even out their heights. */
2246 other
= upper
= lower
= Qnil
;
2247 if (!NILP (XWINDOW (window
)->prev
))
2248 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
2249 if (!NILP (XWINDOW (window
)->next
))
2250 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
2252 /* Check that OTHER and WINDOW are vertically arrayed. */
2253 && !EQ (XWINDOW (other
)->top
, XWINDOW (window
)->top
)
2254 && (XFASTINT (XWINDOW (other
)->height
)
2255 > XFASTINT (XWINDOW (window
)->height
)))
2257 int total
= (XFASTINT (XWINDOW (other
)->height
)
2258 + XFASTINT (XWINDOW (window
)->height
));
2259 Lisp_Object old_selected_window
;
2260 old_selected_window
= selected_window
;
2262 selected_window
= upper
;
2263 change_window_height ((total
/ 2
2264 - XFASTINT (XWINDOW (upper
)->height
)),
2266 selected_window
= old_selected_window
;
2271 window
= Fget_lru_window (Qnil
);
2273 Fset_window_buffer (window
, buffer
);
2274 return display_buffer_1 (window
);
2278 temp_output_buffer_show (buf
)
2279 register Lisp_Object buf
;
2281 register struct buffer
*old
= current_buffer
;
2282 register Lisp_Object window
;
2283 register struct window
*w
;
2285 XBUFFER (buf
)->directory
= current_buffer
->directory
;
2288 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
2292 XBUFFER (buf
)->clip_changed
= 1;
2293 set_buffer_internal (old
);
2295 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
2296 call1 (Vtemp_buffer_show_function
, buf
);
2299 window
= Fdisplay_buffer (buf
, Qnil
);
2301 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2302 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2303 Vminibuf_scroll_window
= window
;
2304 w
= XWINDOW (window
);
2305 XSETFASTINT (w
->hscroll
, 0);
2306 set_marker_restricted (w
->start
, make_number (1), buf
);
2307 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2309 /* Run temp-buffer-show-hook, with the chosen window selected. */
2310 if (!NILP (Vrun_hooks
))
2313 tem
= Fboundp (Qtemp_buffer_show_hook
);
2316 tem
= Fsymbol_value (Qtemp_buffer_show_hook
);
2319 int count
= specpdl_ptr
- specpdl
;
2321 /* Select the window that was chosen, for running the hook. */
2322 record_unwind_protect (Fset_window_configuration
,
2323 Fcurrent_window_configuration (Qnil
));
2325 Fselect_window (window
);
2326 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
2327 unbind_to (count
, Qnil
);
2335 make_dummy_parent (window
)
2339 register struct window
*o
, *p
;
2340 register struct Lisp_Vector
*vec
;
2343 o
= XWINDOW (window
);
2344 vec
= allocate_vectorlike ((EMACS_INT
)VECSIZE (struct window
));
2345 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
2346 vec
->contents
[i
] = ((struct Lisp_Vector
*)o
)->contents
[i
];
2347 vec
->size
= VECSIZE (struct window
);
2348 p
= (struct window
*)vec
;
2349 XSETWINDOW (new, p
);
2351 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
2353 /* Put new into window structure in place of window */
2354 replace_window (window
, new);
2367 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2368 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2369 WINDOW defaults to selected one and SIZE to half its size.\n\
2370 If optional third arg HORFLAG is non-nil, split side by side\n\
2371 and put SIZE columns in the first of the pair.")
2372 (window
, size
, horflag
)
2373 Lisp_Object window
, size
, horflag
;
2375 register Lisp_Object
new;
2376 register struct window
*o
, *p
;
2378 register int size_int
;
2381 window
= selected_window
;
2383 CHECK_LIVE_WINDOW (window
, 0);
2385 o
= XWINDOW (window
);
2386 fo
= XFRAME (WINDOW_FRAME (o
));
2390 if (!NILP (horflag
))
2391 /* Calculate the size of the left-hand window, by dividing
2392 the usable space in columns by two. */
2393 size_int
= XFASTINT (o
->width
) >> 1;
2395 size_int
= XFASTINT (o
->height
) >> 1;
2399 CHECK_NUMBER (size
, 1);
2400 size_int
= XINT (size
);
2403 if (MINI_WINDOW_P (o
))
2404 error ("Attempt to split minibuffer window");
2406 check_min_window_sizes ();
2410 if (size_int
< window_min_height
)
2411 error ("Window height %d too small (after splitting)", size_int
);
2412 if (size_int
+ window_min_height
> XFASTINT (o
->height
))
2413 error ("Window height %d too small (after splitting)",
2414 XFASTINT (o
->height
) - size_int
);
2415 if (NILP (o
->parent
)
2416 || NILP (XWINDOW (o
->parent
)->vchild
))
2418 make_dummy_parent (window
);
2420 XWINDOW (new)->vchild
= window
;
2425 if (size_int
< window_min_width
)
2426 error ("Window width %d too small (after splitting)", size_int
);
2428 if (size_int
+ window_min_width
> XFASTINT (o
->width
))
2429 error ("Window width %d too small (after splitting)",
2430 XFASTINT (o
->width
) - size_int
);
2431 if (NILP (o
->parent
)
2432 || NILP (XWINDOW (o
->parent
)->hchild
))
2434 make_dummy_parent (window
);
2436 XWINDOW (new)->hchild
= window
;
2440 /* Now we know that window's parent is a vertical combination
2441 if we are dividing vertically, or a horizontal combination
2442 if we are making side-by-side windows */
2444 windows_or_buffers_changed
++;
2445 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
2446 new = make_window ();
2449 p
->frame
= o
->frame
;
2451 if (!NILP (p
->next
))
2452 XWINDOW (p
->next
)->prev
= new;
2455 p
->parent
= o
->parent
;
2458 /* Apportion the available frame space among the two new windows */
2460 if (!NILP (horflag
))
2462 p
->height
= o
->height
;
2464 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size_int
);
2465 XSETFASTINT (o
->width
, size_int
);
2466 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size_int
);
2471 p
->width
= o
->width
;
2472 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size_int
);
2473 XSETFASTINT (o
->height
, size_int
);
2474 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size_int
);
2477 Fset_window_buffer (new, o
->buffer
);
2482 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2483 "Make current window ARG lines bigger.\n\
2484 From program, optional second arg non-nil means grow sideways ARG columns.")
2486 register Lisp_Object arg
, side
;
2488 CHECK_NUMBER (arg
, 0);
2489 change_window_height (XINT (arg
), !NILP (side
));
2491 if (! NILP (Vwindow_configuration_change_hook
))
2492 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
2497 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2498 "Make current window ARG lines smaller.\n\
2499 From program, optional second arg non-nil means shrink sideways arg columns.")
2501 register Lisp_Object arg
, side
;
2503 CHECK_NUMBER (arg
, 0);
2504 change_window_height (-XINT (arg
), !NILP (side
));
2506 if (! NILP (Vwindow_configuration_change_hook
))
2507 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
2513 window_height (window
)
2516 register struct window
*p
= XWINDOW (window
);
2517 return XFASTINT (p
->height
);
2521 window_width (window
)
2524 register struct window
*p
= XWINDOW (window
);
2525 return XFASTINT (p
->width
);
2528 #define MINSIZE(w) \
2530 ? window_min_width \
2531 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2534 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2536 #define CURSIZE(w) \
2537 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2539 /* Unlike set_window_height, this function
2540 also changes the heights of the siblings so as to
2541 keep everything consistent. */
2543 change_window_height (delta
, widthflag
)
2547 register Lisp_Object parent
;
2549 register struct window
*p
;
2551 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2552 register int (*setsizefun
) () = (widthflag
2554 : set_window_height
);
2556 Lisp_Object next
, prev
;
2558 check_min_window_sizes ();
2560 window
= selected_window
;
2563 p
= XWINDOW (window
);
2568 error ("No other window to side of this one");
2571 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2572 : !NILP (XWINDOW (parent
)->vchild
))
2577 sizep
= &CURSIZE (window
);
2580 register int maxdelta
;
2582 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2583 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2584 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2585 /* This is a frame with only one window, a minibuffer-only
2586 or a minibufferless frame. */
2589 if (delta
> maxdelta
)
2590 /* This case traps trying to make the minibuffer
2591 the full frame, or make the only window aside from the
2592 minibuffer the full frame. */
2596 if (*sizep
+ delta
< MINSIZE (window
))
2598 delete_window (window
);
2605 /* Find the total we can get from other siblings. */
2607 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
2608 maximum
+= (*sizefun
) (next
) - MINSIZE (next
);
2609 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
2610 maximum
+= (*sizefun
) (prev
) - MINSIZE (prev
);
2612 /* If we can get it all from them, do so. */
2613 if (delta
<= maximum
)
2615 Lisp_Object first_unaffected
;
2616 Lisp_Object first_affected
;
2620 first_affected
= window
;
2621 /* Look at one sibling at a time,
2622 moving away from this window in both directions alternately,
2623 and take as much as we can get without deleting that sibling. */
2630 int this_one
= (*sizefun
) (next
) - MINSIZE (next
);
2631 if (this_one
> delta
)
2634 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
2635 (*setsizefun
) (window
, *sizep
+ this_one
, 0);
2638 next
= XWINDOW (next
)->next
;
2644 int this_one
= (*sizefun
) (prev
) - MINSIZE (prev
);
2645 if (this_one
> delta
)
2648 first_affected
= prev
;
2650 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
2651 (*setsizefun
) (window
, *sizep
+ this_one
, 0);
2654 prev
= XWINDOW (prev
)->prev
;
2658 /* Now recalculate the edge positions of all the windows affected,
2659 based on the new sizes. */
2660 first_unaffected
= next
;
2661 prev
= first_affected
;
2662 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
2663 prev
= next
, next
= XWINDOW (next
)->next
)
2665 CURBEG (next
) = CURBEG (prev
) + (*sizefun
) (prev
);
2666 /* This does not change size of NEXT,
2667 but it propagates the new top edge to its children */
2668 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
2673 register int delta1
;
2674 register int opht
= (*sizefun
) (parent
);
2676 /* If trying to grow this window to or beyond size of the parent,
2677 make delta1 so big that, on shrinking back down,
2678 all the siblings end up with less than one line and are deleted. */
2679 if (opht
<= *sizep
+ delta
)
2680 delta1
= opht
* opht
* 2;
2681 /* Otherwise, make delta1 just right so that if we add delta1
2682 lines to this window and to the parent, and then shrink
2683 the parent back to its original size, the new proportional
2684 size of this window will increase by delta. */
2686 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2688 /* Add delta1 lines or columns to this window, and to the parent,
2689 keeping things consistent while not affecting siblings. */
2690 CURSIZE (parent
) = opht
+ delta1
;
2691 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2693 /* Squeeze out delta1 lines or columns from our parent,
2694 shriking this window and siblings proportionately.
2695 This brings parent back to correct size.
2696 Delta1 was calculated so this makes this window the desired size,
2697 taking it all out of the siblings. */
2698 (*setsizefun
) (parent
, opht
, 0);
2701 XSETFASTINT (p
->last_modified
, 0);
2702 XSETFASTINT (p
->last_overlay_modified
, 0);
2709 /* Return number of lines of text (not counting mode line) in W. */
2712 window_internal_height (w
)
2715 int ht
= XFASTINT (w
->height
);
2717 if (MINI_WINDOW_P (w
))
2720 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2721 || !NILP (w
->next
) || !NILP (w
->prev
)
2722 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2729 /* Return the number of columns in W.
2730 Don't count columns occupied by scroll bars or the vertical bar
2731 separating W from the sibling to its right. */
2733 window_internal_width (w
)
2736 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2737 int width
= XINT (w
->width
);
2739 /* Scroll bars occupy a few columns. */
2740 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2741 return width
- FRAME_SCROLL_BAR_COLS (f
);
2743 /* The column of `|' characters separating side-by-side windows
2744 occupies one column only. */
2745 if (!WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
2752 /* Scroll contents of window WINDOW up N lines.
2753 If WHOLE is nonzero, it means scroll N screenfuls instead. */
2756 window_scroll (window
, n
, whole
, noerror
)
2762 register struct window
*w
= XWINDOW (window
);
2763 register int opoint
= PT
;
2765 register int ht
= window_internal_height (w
);
2766 register Lisp_Object tem
;
2768 Lisp_Object bolp
, nmoved
;
2770 struct position posit
;
2773 startpos
= marker_position (w
->start
);
2775 posit
= *compute_motion (startpos
, 0, 0, 0,
2777 window_internal_width (w
), XINT (w
->hscroll
),
2779 original_vpos
= posit
.vpos
;
2781 XSETFASTINT (tem
, PT
);
2782 tem
= Fpos_visible_in_window_p (tem
, window
);
2786 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2791 lose
= n
< 0 && PT
== BEGV
;
2792 Fvertical_motion (make_number (n
), window
);
2802 Fsignal (Qbeginning_of_buffer
, Qnil
);
2807 int this_scroll_margin
= scroll_margin
;
2809 /* Don't use a scroll margin that is negative or too large. */
2810 if (this_scroll_margin
< 0)
2811 this_scroll_margin
= 0;
2813 if (XINT (w
->height
) < 4 * scroll_margin
)
2814 this_scroll_margin
= XINT (w
->height
) / 4;
2816 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2817 w
->start_at_line_beg
= bolp
;
2818 w
->update_mode_line
= Qt
;
2819 XSETFASTINT (w
->last_modified
, 0);
2820 XSETFASTINT (w
->last_overlay_modified
, 0);
2821 /* Set force_start so that redisplay_window will run
2822 the window-scroll-functions. */
2823 w
->force_start
= Qt
;
2825 if (whole
&& scroll_preserve_screen_position
)
2828 Fvertical_motion (make_number (original_vpos
), window
);
2830 /* If we scrolled forward, put point enough lines down
2831 that it is outside the scroll margin. */
2836 if (this_scroll_margin
> 0)
2839 Fvertical_motion (make_number (this_scroll_margin
), window
);
2845 if (top_margin
<= opoint
)
2847 else if (scroll_preserve_screen_position
)
2850 Fvertical_motion (make_number (original_vpos
), window
);
2859 /* If we scrolled backward, put point near the end of the window
2860 but not within the scroll margin. */
2862 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
2863 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
2866 bottom_margin
= PT
+ 1;
2868 if (bottom_margin
> opoint
)
2872 if (scroll_preserve_screen_position
)
2875 Fvertical_motion (make_number (original_vpos
), window
);
2878 Fvertical_motion (make_number (-1), window
);
2887 Fsignal (Qend_of_buffer
, Qnil
);
2891 /* This is the guts of Fscroll_up and Fscroll_down. */
2894 scroll_command (n
, direction
)
2895 register Lisp_Object n
;
2898 register int defalt
;
2899 int count
= specpdl_ptr
- specpdl
;
2901 /* If selected window's buffer isn't current, make it current for the moment.
2902 But don't screw up if window_scroll gets an error. */
2903 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2905 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2906 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2909 defalt
= (window_internal_height (XWINDOW (selected_window
))
2910 - next_screen_context_lines
);
2911 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2914 window_scroll (selected_window
, defalt
, 1, 0);
2915 else if (EQ (n
, Qminus
))
2916 window_scroll (selected_window
, - defalt
, 1, 0);
2919 n
= Fprefix_numeric_value (n
);
2920 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
2923 unbind_to (count
, Qnil
);
2926 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2927 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2928 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2929 Negative ARG means scroll downward.\n\
2930 When calling from a program, supply a number as argument or nil.")
2934 scroll_command (arg
, 1);
2938 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2939 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2940 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2941 Negative ARG means scroll upward.\n\
2942 When calling from a program, supply a number as argument or nil.")
2946 scroll_command (arg
, -1);
2950 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2951 "Return the other window for \"other window scroll\" commands.\n\
2952 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2953 specifies the window.\n\
2954 If `other-window-scroll-buffer' is non-nil, a window\n\
2955 showing that buffer is used.")
2960 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2961 && !NILP (Vminibuf_scroll_window
))
2962 window
= Vminibuf_scroll_window
;
2963 /* If buffer is specified, scroll that buffer. */
2964 else if (!NILP (Vother_window_scroll_buffer
))
2966 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2968 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2972 /* Nothing specified; look for a neighboring window on the same
2974 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2976 if (EQ (window
, selected_window
))
2977 /* That didn't get us anywhere; look for a window on another
2980 window
= Fnext_window (window
, Qnil
, Qt
);
2981 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2982 && ! EQ (window
, selected_window
));
2985 CHECK_LIVE_WINDOW (window
, 0);
2987 if (EQ (window
, selected_window
))
2988 error ("There is no other window");
2993 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2994 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2995 The next window is the one below the current one; or the one at the top\n\
2996 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2997 When calling from a program, supply a number as argument or nil.\n\
2999 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
3000 specifies the window to scroll.\n\
3001 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
3002 showing that buffer, popping the buffer up if necessary.")
3004 register Lisp_Object arg
;
3006 register Lisp_Object window
;
3007 register int defalt
;
3008 register struct window
*w
;
3009 register int count
= specpdl_ptr
- specpdl
;
3011 window
= Fother_window_for_scrolling ();
3013 w
= XWINDOW (window
);
3014 defalt
= window_internal_height (w
) - next_screen_context_lines
;
3015 if (defalt
< 1) defalt
= 1;
3017 /* Don't screw up if window_scroll gets an error. */
3018 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
3020 Fset_buffer (w
->buffer
);
3021 SET_PT (marker_position (w
->pointm
));
3024 window_scroll (window
, defalt
, 1, 1);
3025 else if (EQ (arg
, Qminus
))
3026 window_scroll (window
, -defalt
, 1, 1);
3031 CHECK_NUMBER (arg
, 0);
3032 window_scroll (window
, XINT (arg
), 0, 1);
3035 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
3036 unbind_to (count
, Qnil
);
3041 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
3042 "Scroll selected window display ARG columns left.\n\
3043 Default for ARG is window width minus 2.")
3045 register Lisp_Object arg
;
3049 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
3051 arg
= Fprefix_numeric_value (arg
);
3054 Fset_window_hscroll (selected_window
,
3055 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
3059 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
3060 "Scroll selected window display ARG columns right.\n\
3061 Default for ARG is window width minus 2.")
3063 register Lisp_Object arg
;
3066 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
3068 arg
= Fprefix_numeric_value (arg
);
3071 Fset_window_hscroll (selected_window
,
3072 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
3076 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
3077 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
3078 The desired position of point is always relative to the current window.\n\
3079 Just C-u as prefix means put point in the center of the window.\n\
3080 If ARG is omitted or nil, erases the entire frame and then\n\
3081 redraws with point in the center of the current window.")
3083 register Lisp_Object arg
;
3085 register struct window
*w
= XWINDOW (selected_window
);
3086 register int ht
= window_internal_height (w
);
3087 struct position pos
;
3091 extern int frame_garbaged
;
3093 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
3094 XSETFASTINT (arg
, ht
/ 2);
3096 else if (CONSP (arg
)) /* Just C-u. */
3098 XSETFASTINT (arg
, ht
/ 2);
3102 arg
= Fprefix_numeric_value (arg
);
3103 CHECK_NUMBER (arg
, 0);
3107 XSETINT (arg
, XINT (arg
) + ht
);
3109 pos
= *vmotion (PT
, - XINT (arg
), w
);
3111 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
3112 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
3113 || FETCH_BYTE (pos
.bufpos
- 1) == '\n')
3115 w
->force_start
= Qt
;
3120 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
3122 "Position point relative to window.\n\
3123 With no argument, position point at center of window.\n\
3124 An argument specifies frame line; zero means top of window,\n\
3125 negative means relative to bottom of window.")
3127 register Lisp_Object arg
;
3129 register struct window
*w
= XWINDOW (selected_window
);
3130 register int height
= window_internal_height (w
);
3135 XSETFASTINT (arg
, height
/ 2);
3138 arg
= Fprefix_numeric_value (arg
);
3140 XSETINT (arg
, XINT (arg
) + height
);
3143 start
= marker_position (w
->start
);
3144 XSETWINDOW (window
, w
);
3145 if (start
< BEGV
|| start
> ZV
)
3147 Fvertical_motion (make_number (- (height
/ 2)), window
);
3148 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
3149 w
->start_at_line_beg
= Fbolp ();
3150 w
->force_start
= Qt
;
3155 return Fvertical_motion (arg
, window
);
3158 struct save_window_data
3160 EMACS_INT size_from_Lisp_Vector_struct
;
3161 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
3162 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
3163 Lisp_Object selected_frame
;
3164 Lisp_Object current_window
;
3165 Lisp_Object current_buffer
;
3166 Lisp_Object minibuf_scroll_window
;
3167 Lisp_Object root_window
;
3168 Lisp_Object focus_frame
;
3169 /* Record the values of window-min-width and window-min-height
3170 so that window sizes remain consistent with them. */
3171 Lisp_Object min_width
, min_height
;
3172 /* A vector, interpreted as a struct saved_window */
3173 Lisp_Object saved_windows
;
3176 /* This is saved as a Lisp_Vector */
3179 /* these first two must agree with struct Lisp_Vector in lisp.h */
3180 EMACS_INT size_from_Lisp_Vector_struct
;
3181 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
3184 Lisp_Object buffer
, start
, pointm
, mark
;
3185 Lisp_Object left
, top
, width
, height
, hscroll
;
3186 Lisp_Object parent
, prev
;
3187 Lisp_Object start_at_line_beg
;
3188 Lisp_Object display_table
;
3190 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
3192 #define SAVED_WINDOW_N(swv,n) \
3193 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
3195 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
3196 "T if OBJECT is a window-configuration object.")
3200 if (WINDOW_CONFIGURATIONP (object
))
3206 DEFUN ("set-window-configuration", Fset_window_configuration
,
3207 Sset_window_configuration
, 1, 1, 0,
3208 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
3209 CONFIGURATION must be a value previously returned\n\
3210 by `current-window-configuration' (which see).")
3212 Lisp_Object configuration
;
3214 register struct save_window_data
*data
;
3215 struct Lisp_Vector
*saved_windows
;
3216 Lisp_Object new_current_buffer
;
3221 while (!WINDOW_CONFIGURATIONP (configuration
))
3223 configuration
= wrong_type_argument (intern ("window-configuration-p"),
3227 data
= (struct save_window_data
*) XVECTOR (configuration
);
3228 saved_windows
= XVECTOR (data
->saved_windows
);
3230 new_current_buffer
= data
->current_buffer
;
3231 if (NILP (XBUFFER (new_current_buffer
)->name
))
3232 new_current_buffer
= Qnil
;
3235 if (XBUFFER (new_current_buffer
) == current_buffer
)
3239 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
3242 /* If f is a dead frame, don't bother rebuilding its window tree.
3243 However, there is other stuff we should still try to do below. */
3244 if (FRAME_LIVE_P (f
))
3246 register struct window
*w
;
3247 register struct saved_window
*p
;
3250 /* If the frame has been resized since this window configuration was
3251 made, we change the frame to the size specified in the
3252 configuration, restore the configuration, and then resize it
3253 back. We keep track of the prevailing height in these variables. */
3254 int previous_frame_height
= FRAME_HEIGHT (f
);
3255 int previous_frame_width
= FRAME_WIDTH (f
);
3256 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
3258 /* The mouse highlighting code could get screwed up
3259 if it runs during this. */
3262 if (XFASTINT (data
->frame_height
) != previous_frame_height
3263 || XFASTINT (data
->frame_width
) != previous_frame_width
)
3264 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
3265 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
3266 if (XFASTINT (data
->frame_menu_bar_lines
)
3267 != previous_frame_menu_bar_lines
)
3268 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
3271 windows_or_buffers_changed
++;
3272 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3274 /* Temporarily avoid any problems with windows that are smaller
3275 than they are supposed to be. */
3276 window_min_height
= 1;
3277 window_min_width
= 1;
3280 Mark all windows now on frame as "deleted".
3281 Restoring the new configuration "undeletes" any that are in it.
3283 Save their current buffers in their height fields, since we may
3284 need it later, if a buffer saved in the configuration is now
3286 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3288 for (k
= 0; k
< saved_windows
->size
; k
++)
3290 p
= SAVED_WINDOW_N (saved_windows
, k
);
3291 w
= XWINDOW (p
->window
);
3294 if (!NILP (p
->parent
))
3295 w
->parent
= SAVED_WINDOW_N (saved_windows
,
3296 XFASTINT (p
->parent
))->window
;
3300 if (!NILP (p
->prev
))
3302 w
->prev
= SAVED_WINDOW_N (saved_windows
,
3303 XFASTINT (p
->prev
))->window
;
3304 XWINDOW (w
->prev
)->next
= p
->window
;
3309 if (!NILP (w
->parent
))
3311 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
3313 XWINDOW (w
->parent
)->vchild
= p
->window
;
3314 XWINDOW (w
->parent
)->hchild
= Qnil
;
3318 XWINDOW (w
->parent
)->hchild
= p
->window
;
3319 XWINDOW (w
->parent
)->vchild
= Qnil
;
3324 /* If we squirreled away the buffer in the window's height,
3326 if (BUFFERP (w
->height
))
3327 w
->buffer
= w
->height
;
3330 w
->width
= p
->width
;
3331 w
->height
= p
->height
;
3332 w
->hscroll
= p
->hscroll
;
3333 w
->display_table
= p
->display_table
;
3334 XSETFASTINT (w
->last_modified
, 0);
3335 XSETFASTINT (w
->last_overlay_modified
, 0);
3337 /* Reinstall the saved buffer and pointers into it. */
3338 if (NILP (p
->buffer
))
3339 w
->buffer
= p
->buffer
;
3342 if (!NILP (XBUFFER (p
->buffer
)->name
))
3343 /* If saved buffer is alive, install it. */
3345 w
->buffer
= p
->buffer
;
3346 w
->start_at_line_beg
= p
->start_at_line_beg
;
3347 set_marker_restricted (w
->start
,
3348 Fmarker_position (p
->start
),
3350 set_marker_restricted (w
->pointm
,
3351 Fmarker_position (p
->pointm
),
3353 Fset_marker (XBUFFER (w
->buffer
)->mark
,
3354 Fmarker_position (p
->mark
), w
->buffer
);
3356 /* As documented in Fcurrent_window_configuration, don't
3357 save the location of point in the buffer which was current
3358 when the window configuration was recorded. */
3359 if (!EQ (p
->buffer
, new_current_buffer
)
3360 && XBUFFER (p
->buffer
) == current_buffer
)
3361 Fgoto_char (w
->pointm
);
3363 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
3364 /* Else unless window has a live buffer, get one. */
3366 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
3367 /* This will set the markers to beginning of visible
3369 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
3370 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
3371 w
->start_at_line_beg
= Qt
;
3374 /* Keeping window's old buffer; make sure the markers
3377 /* Set window markers at start of visible range. */
3378 if (XMARKER (w
->start
)->buffer
== 0)
3379 set_marker_restricted (w
->start
, make_number (0),
3381 if (XMARKER (w
->pointm
)->buffer
== 0)
3382 set_marker_restricted (w
->pointm
,
3384 (BUF_PT (XBUFFER (w
->buffer
)))),
3386 w
->start_at_line_beg
= Qt
;
3391 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
3392 Fselect_window (data
->current_window
);
3393 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
3396 if (NILP (data
->focus_frame
)
3397 || (FRAMEP (data
->focus_frame
)
3398 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
3399 Fredirect_frame_focus (frame
, data
->focus_frame
);
3401 #if 0 /* I don't understand why this is needed, and it causes problems
3402 when the frame's old selected window has been deleted. */
3403 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
3404 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
3408 /* Set the screen height to the value it had before this function. */
3409 if (previous_frame_height
!= FRAME_HEIGHT (f
)
3410 || previous_frame_width
!= FRAME_WIDTH (f
))
3411 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
3413 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
3414 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
3415 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
3421 /* Restore the minimum heights recorded in the configuration. */
3422 window_min_height
= XINT (data
->min_height
);
3423 window_min_width
= XINT (data
->min_width
);
3425 /* Fselect_window will have made f the selected frame, so we
3426 reselect the proper frame here. Fhandle_switch_frame will change the
3427 selected window too, but that doesn't make the call to
3428 Fselect_window above totally superfluous; it still sets f's
3430 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
3431 do_switch_frame (data
->selected_frame
, Qnil
, 0);
3433 if (!NILP (new_current_buffer
))
3435 Fset_buffer (new_current_buffer
);
3437 /* If the buffer that is current now is the same
3438 that was current before setting the window configuration,
3439 don't alter its PT. */
3444 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
3446 if (! NILP (Vwindow_configuration_change_hook
)
3447 && ! NILP (Vrun_hooks
))
3448 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3453 /* Mark all windows now on frame as deleted
3454 by setting their buffers to nil. */
3457 delete_all_subwindows (w
)
3458 register struct window
*w
;
3460 if (!NILP (w
->next
))
3461 delete_all_subwindows (XWINDOW (w
->next
));
3462 if (!NILP (w
->vchild
))
3463 delete_all_subwindows (XWINDOW (w
->vchild
));
3464 if (!NILP (w
->hchild
))
3465 delete_all_subwindows (XWINDOW (w
->hchild
));
3467 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3469 if (!NILP (w
->buffer
))
3472 /* We set all three of these fields to nil, to make sure that we can
3473 distinguish this dead window from any live window. Live leaf
3474 windows will have buffer set, and combination windows will have
3475 vchild or hchild set. */
3482 count_windows (window
)
3483 register struct window
*window
;
3485 register int count
= 1;
3486 if (!NILP (window
->next
))
3487 count
+= count_windows (XWINDOW (window
->next
));
3488 if (!NILP (window
->vchild
))
3489 count
+= count_windows (XWINDOW (window
->vchild
));
3490 if (!NILP (window
->hchild
))
3491 count
+= count_windows (XWINDOW (window
->hchild
));
3496 save_window_save (window
, vector
, i
)
3498 struct Lisp_Vector
*vector
;
3501 register struct saved_window
*p
;
3502 register struct window
*w
;
3503 register Lisp_Object tem
;
3505 for (;!NILP (window
); window
= w
->next
)
3507 p
= SAVED_WINDOW_N (vector
, i
);
3508 w
= XWINDOW (window
);
3510 XSETFASTINT (w
->temslot
, i
++);
3512 p
->buffer
= w
->buffer
;
3515 p
->width
= w
->width
;
3516 p
->height
= w
->height
;
3517 p
->hscroll
= w
->hscroll
;
3518 p
->display_table
= w
->display_table
;
3519 if (!NILP (w
->buffer
))
3521 /* Save w's value of point in the window configuration.
3522 If w is the selected window, then get the value of point
3523 from the buffer; pointm is garbage in the selected window. */
3524 if (EQ (window
, selected_window
))
3526 p
->pointm
= Fmake_marker ();
3527 Fset_marker (p
->pointm
,
3528 make_number (BUF_PT (XBUFFER (w
->buffer
))),
3532 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
3534 p
->start
= Fcopy_marker (w
->start
, Qnil
);
3535 p
->start_at_line_beg
= w
->start_at_line_beg
;
3537 tem
= XBUFFER (w
->buffer
)->mark
;
3538 p
->mark
= Fcopy_marker (tem
, Qnil
);
3545 p
->start_at_line_beg
= Qnil
;
3548 if (NILP (w
->parent
))
3551 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3556 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3558 if (!NILP (w
->vchild
))
3559 i
= save_window_save (w
->vchild
, vector
, i
);
3560 if (!NILP (w
->hchild
))
3561 i
= save_window_save (w
->hchild
, vector
, i
);
3567 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
3568 Scurrent_window_configuration
, 0, 1, 0,
3569 "Return an object representing the current window configuration of FRAME.\n\
3570 If FRAME is nil or omitted, use the selected frame.\n\
3571 This describes the number of windows, their sizes and current buffers,\n\
3572 and for each displayed buffer, where display starts, and the positions of\n\
3573 point and mark. An exception is made for point in the current buffer:\n\
3574 its value is -not- saved.\n\
3575 This also records the currently selected frame, and FRAME's focus\n\
3576 redirection (see `redirect-frame-focus').")
3580 register Lisp_Object tem
;
3581 register int n_windows
;
3582 register struct save_window_data
*data
;
3583 register struct Lisp_Vector
*vec
;
3591 CHECK_LIVE_FRAME (frame
, 0);
3595 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3596 vec
= allocate_vectorlike (VECSIZE (struct save_window_data
));
3597 for (i
= 0; i
< VECSIZE (struct save_window_data
); i
++)
3598 vec
->contents
[i
] = Qnil
;
3599 vec
->size
= VECSIZE (struct save_window_data
);
3600 data
= (struct save_window_data
*)vec
;
3602 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
3603 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
3604 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
3605 XSETFRAME (data
->selected_frame
, selected_frame
);
3606 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3607 XSETBUFFER (data
->current_buffer
, current_buffer
);
3608 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3609 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3610 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3611 XSETINT (data
->min_height
, window_min_height
);
3612 XSETINT (data
->min_width
, window_min_width
);
3613 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3614 data
->saved_windows
= tem
;
3615 for (i
= 0; i
< n_windows
; i
++)
3616 XVECTOR (tem
)->contents
[i
]
3617 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3618 save_window_save (FRAME_ROOT_WINDOW (f
),
3620 XSETWINDOW_CONFIGURATION (tem
, data
);
3624 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3626 "Execute body, preserving window sizes and contents.\n\
3627 Restore which buffer appears in which window, where display starts,\n\
3628 and the value of point and mark for each window.\n\
3629 Also restore which buffer is current.\n\
3630 But do not preserve point in the current buffer.\n\
3631 Does not restore the value of point in current buffer.")
3635 register Lisp_Object val
;
3636 register int count
= specpdl_ptr
- specpdl
;
3638 record_unwind_protect (Fset_window_configuration
,
3639 Fcurrent_window_configuration (Qnil
));
3640 val
= Fprogn (args
);
3641 return unbind_to (count
, val
);
3646 selected_frame
= make_terminal_frame ();
3647 XSETFRAME (Vterminal_frame
, selected_frame
);
3648 minibuf_window
= selected_frame
->minibuffer_window
;
3649 selected_window
= selected_frame
->selected_window
;
3650 last_nonminibuf_frame
= selected_frame
;
3652 window_initialized
= 1;
3657 staticpro (&Qwindow_configuration_change_hook
);
3658 Qwindow_configuration_change_hook
3659 = intern ("window-configuration-change-hook");
3661 Qwindowp
= intern ("windowp");
3662 staticpro (&Qwindowp
);
3664 Qwindow_live_p
= intern ("window-live-p");
3665 staticpro (&Qwindow_live_p
);
3667 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
3668 staticpro (&Qtemp_buffer_show_hook
);
3670 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3671 "Non-nil means call as function to display a help buffer.\n\
3672 The function is called with one argument, the buffer to be displayed.\n\
3673 Used by `with-output-to-temp-buffer'.\n\
3674 If this function is used, then it must do the entire job of showing\n\
3675 the buffer; `temp-buffer-show-hook' is not run unless this function runs it.");
3676 Vtemp_buffer_show_function
= Qnil
;
3678 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3679 "If non-nil, function to call to handle `display-buffer'.\n\
3680 It will receive two args, the buffer and a flag which if non-nil means\n\
3681 that the currently selected window is not acceptable.\n\
3682 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3683 work using this function.");
3684 Vdisplay_buffer_function
= Qnil
;
3686 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3687 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3688 Vminibuf_scroll_window
= Qnil
;
3690 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3691 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3692 Vother_window_scroll_buffer
= Qnil
;
3694 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3695 "*Non-nil means `display-buffer' should make a separate frame.");
3698 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3699 "Function to call to handle automatic new frame creation.\n\
3700 It is called with no arguments and should return a newly created frame.\n\
3702 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3703 where `pop-up-frame-alist' would hold the default frame parameters.");
3704 Vpop_up_frame_function
= Qnil
;
3706 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3707 "*List of buffer names that should have their own special frames.\n\
3708 Displaying a buffer whose name is in this list makes a special frame for it\n\
3709 using `special-display-function'. See also `special-display-regexps'.\n\
3711 An element of the list can be a list instead of just a string.\n\
3712 There are two ways to use a list as an element:\n\
3713 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)\n\
3714 In the first case, FRAME-PARAMETERS are used to create the frame.\n\
3715 In the latter case, FUNCTION is called with BUFFER as the first argument,\n\
3716 followed by OTHER-ARGS--it can display BUFFER in any way it likes.\n\
3717 All this is done by the function found in `special-display-function'.\n\
3719 If this variable appears \"not to work\", because you add a name to it\n\
3720 but that buffer still appears in the selected window, look at the\n\
3721 values of `same-window-buffer-names' and `same-window-regexps'.\n\
3722 Those variables take precedence over this one.");
3723 Vspecial_display_buffer_names
= Qnil
;
3725 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3726 "*List of regexps saying which buffers should have their own special frames.\n\
3727 If a buffer name matches one of these regexps, it gets its own frame.\n\
3728 Displaying a buffer whose name is in this list makes a special frame for it\n\
3729 using `special-display-function'.\n\
3731 An element of the list can be a list instead of just a string.\n\
3732 There are two ways to use a list as an element:\n\
3733 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)\n\
3734 In the first case, FRAME-PARAMETERS are used to create the frame.\n\
3735 In the latter case, FUNCTION is called with the buffer as first argument,\n\
3736 followed by OTHER-ARGS--it can display the buffer in any way it likes.\n\
3737 All this is done by the function found in `special-display-function'.\n\
3739 If this variable appears \"not to work\", because you add a regexp to it\n\
3740 but the matching buffers still appear in the selected window, look at the\n\
3741 values of `same-window-buffer-names' and `same-window-regexps'.\n\
3742 Those variables take precedence over this one.");
3743 Vspecial_display_regexps
= Qnil
;
3745 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3746 "Function to call to make a new frame for a special buffer.\n\
3747 It is called with two arguments, the buffer and optional buffer specific\n\
3748 data, and should return a window displaying that buffer.\n\
3749 The default value makes a separate frame for the buffer,\n\
3750 using `special-display-frame-alist' to specify the frame parameters.\n\
3752 A buffer is special if its is listed in `special-display-buffer-names'\n\
3753 or matches a regexp in `special-display-regexps'.");
3754 Vspecial_display_function
= Qnil
;
3756 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
3757 "*List of buffer names that should appear in the selected window.\n\
3758 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
3759 switches to it in the selected window, rather than making it appear\n\
3760 in some other window.\n\
3762 An element of the list can be a cons cell instead of just a string.\n\
3763 Then the car must be a string, which specifies the buffer name.\n\
3764 This is for compatibility with `special-display-buffer-names';\n\
3765 the cdr of the cons cell is ignored.\n\
3767 See also `same-window-regexps'.");
3768 Vsame_window_buffer_names
= Qnil
;
3770 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
3771 "*List of regexps saying which buffers should appear in the selected window.\n\
3772 If a buffer name matches one of these regexps, then displaying it\n\
3773 using `display-buffer' or `pop-to-buffer' switches to it\n\
3774 in the selected window, rather than making it appear in some other window.\n\
3776 An element of the list can be a cons cell instead of just a string.\n\
3777 Then the car must be a string, which specifies the buffer name.\n\
3778 This is for compatibility with `special-display-buffer-names';\n\
3779 the cdr of the cons cell is ignored.\n\
3781 See also `same-window-buffer-names'.");
3782 Vsame_window_regexps
= Qnil
;
3784 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3785 "*Non-nil means display-buffer should make new windows.");
3788 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3789 "*Number of lines of continuity when scrolling by screenfuls.");
3790 next_screen_context_lines
= 2;
3792 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3793 "*display-buffer would prefer to split the largest window if this large.\n\
3794 If there is only one window, it is split regardless of this value.");
3795 split_height_threshold
= 500;
3797 DEFVAR_INT ("window-min-height", &window_min_height
,
3798 "*Delete any window less than this tall (including its mode line).");
3799 window_min_height
= 4;
3801 DEFVAR_INT ("window-min-width", &window_min_width
,
3802 "*Delete any window less than this wide.");
3803 window_min_width
= 10;
3805 DEFVAR_BOOL ("scroll-preserve-screen-position",
3806 &scroll_preserve_screen_position
,
3807 "*Nonzero means scroll commands move point to keep its screen line unchanged.");
3808 scroll_preserve_screen_position
= 0;
3810 DEFVAR_LISP ("window-configuration-change-hook",
3811 &Vwindow_configuration_change_hook
,
3812 "Functions to call when window configuration changes.\n\
3813 The selected frae is the one whose configuration has changed.");
3814 Vwindow_configuration_change_hook
= Qnil
;
3816 defsubr (&Sselected_window
);
3817 defsubr (&Sminibuffer_window
);
3818 defsubr (&Swindow_minibuffer_p
);
3819 defsubr (&Swindowp
);
3820 defsubr (&Swindow_live_p
);
3821 defsubr (&Spos_visible_in_window_p
);
3822 defsubr (&Swindow_buffer
);
3823 defsubr (&Swindow_height
);
3824 defsubr (&Swindow_width
);
3825 defsubr (&Swindow_hscroll
);
3826 defsubr (&Sset_window_hscroll
);
3827 defsubr (&Swindow_redisplay_end_trigger
);
3828 defsubr (&Sset_window_redisplay_end_trigger
);
3829 defsubr (&Swindow_edges
);
3830 defsubr (&Scoordinates_in_window_p
);
3831 defsubr (&Swindow_at
);
3832 defsubr (&Swindow_point
);
3833 defsubr (&Swindow_start
);
3834 defsubr (&Swindow_end
);
3835 defsubr (&Sset_window_point
);
3836 defsubr (&Sset_window_start
);
3837 defsubr (&Swindow_dedicated_p
);
3838 defsubr (&Sset_window_dedicated_p
);
3839 defsubr (&Swindow_display_table
);
3840 defsubr (&Sset_window_display_table
);
3841 defsubr (&Snext_window
);
3842 defsubr (&Sprevious_window
);
3843 defsubr (&Sother_window
);
3844 defsubr (&Sget_lru_window
);
3845 defsubr (&Sget_largest_window
);
3846 defsubr (&Sget_buffer_window
);
3847 defsubr (&Sdelete_other_windows
);
3848 defsubr (&Sdelete_windows_on
);
3849 defsubr (&Sreplace_buffer_in_windows
);
3850 defsubr (&Sdelete_window
);
3851 defsubr (&Sset_window_buffer
);
3852 defsubr (&Sselect_window
);
3853 defsubr (&Sspecial_display_p
);
3854 defsubr (&Ssame_window_p
);
3855 defsubr (&Sdisplay_buffer
);
3856 defsubr (&Ssplit_window
);
3857 defsubr (&Senlarge_window
);
3858 defsubr (&Sshrink_window
);
3859 defsubr (&Sscroll_up
);
3860 defsubr (&Sscroll_down
);
3861 defsubr (&Sscroll_left
);
3862 defsubr (&Sscroll_right
);
3863 defsubr (&Sother_window_for_scrolling
);
3864 defsubr (&Sscroll_other_window
);
3865 defsubr (&Srecenter
);
3866 defsubr (&Smove_to_window_line
);
3867 defsubr (&Swindow_configuration_p
);
3868 defsubr (&Sset_window_configuration
);
3869 defsubr (&Scurrent_window_configuration
);
3870 defsubr (&Ssave_window_excursion
);
3875 initial_define_key (control_x_map
, '1', "delete-other-windows");
3876 initial_define_key (control_x_map
, '2', "split-window");
3877 initial_define_key (control_x_map
, '0', "delete-window");
3878 initial_define_key (control_x_map
, 'o', "other-window");
3879 initial_define_key (control_x_map
, '^', "enlarge-window");
3880 initial_define_key (control_x_map
, '<', "scroll-left");
3881 initial_define_key (control_x_map
, '>', "scroll-right");
3883 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3884 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3885 initial_define_key (meta_map
, 'v', "scroll-down");
3887 initial_define_key (global_map
, Ctl('L'), "recenter");
3888 initial_define_key (meta_map
, 'r', "move-to-window-line");