1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 Lisp_Object Qwindowp
, Qwindow_live_p
;
34 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
35 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
37 void delete_all_subwindows ();
38 static struct window
*decode_window();
40 /* This is the window in which the terminal's cursor should
41 be left when nothing is being done with it. This must
42 always be a leaf window, and its buffer is selected by
43 the top level editing loop at the end of each command.
45 This value is always the same as
46 FRAME_SELECTED_WINDOW (selected_frame). */
48 Lisp_Object selected_window
;
50 /* The minibuffer window of the selected frame.
51 Note that you cannot test for minibufferness of an arbitrary window
52 by comparing against this; but you can test for minibufferness of
53 the selected window. */
54 Lisp_Object minibuf_window
;
56 /* Non-nil means it is the window for C-M-v to scroll
57 when the minibuffer is selected. */
58 Lisp_Object Vminibuf_scroll_window
;
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
61 Lisp_Object Vother_window_scroll_buffer
;
63 /* Non-nil means it's function to call to display temp buffers. */
64 Lisp_Object Vtemp_buffer_show_function
;
66 /* If a window gets smaller than either of these, it is removed. */
67 int window_min_height
;
70 /* Nonzero implies Fdisplay_buffer should create windows. */
73 /* Nonzero implies make new frames for Fdisplay_buffer. */
76 /* Non-nil means use this function instead of default */
77 Lisp_Object Vpop_up_frame_function
;
79 /* Function to call to handle Fdisplay_buffer. */
80 Lisp_Object Vdisplay_buffer_function
;
82 /* Fdisplay_buffer always splits the largest window
83 if that window is more than this high. */
84 int split_height_threshold
;
86 /* Number of lines of continuity in scrolling by screenfuls. */
87 int next_screen_context_lines
;
89 /* Incremented for each window created. */
90 static int sequence_number
;
92 #define min(a, b) ((a) < (b) ? (a) : (b))
94 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
95 "Returns t if OBJ is a window.")
99 return XTYPE (obj
) == Lisp_Window
? Qt
: Qnil
;
102 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
103 "Returns t if OBJ is a window which is currently visible.")
107 return ((XTYPE (obj
) == Lisp_Window
108 && ! NILP (XWINDOW (obj
)->buffer
))
115 register Lisp_Object val
;
116 register struct window
*p
;
118 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector)
119 includes the first element. */
121 make_number ((sizeof (struct window
) - sizeof (struct Lisp_Vector
)
122 + sizeof (Lisp_Object
))
123 / sizeof (Lisp_Object
)),
125 XSETTYPE (val
, Lisp_Window
);
127 XFASTINT (p
->sequence_number
) = ++sequence_number
;
128 XFASTINT (p
->left
) = XFASTINT (p
->top
)
129 = XFASTINT (p
->height
) = XFASTINT (p
->width
)
130 = XFASTINT (p
->hscroll
) = 0;
131 XFASTINT (p
->last_point_x
) = XFASTINT (p
->last_point_y
) = 0;
132 p
->start
= Fmake_marker ();
133 p
->pointm
= Fmake_marker ();
134 XFASTINT (p
->use_time
) = 0;
136 p
->display_table
= Qnil
;
141 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
142 "Return the window that the cursor now appears in and commands apply to.")
145 return selected_window
;
148 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
149 "Return the window used now for minibuffers.\n\
150 If the optional argument FRAME is specified, return the minibuffer window\n\
151 used by that frame.")
157 XSET (frame
, Lisp_Frame
, selected_frame
);
159 CHECK_LIVE_FRAME (frame
, 0);
162 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
165 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
166 "Returns non-nil if WINDOW is a minibuffer window.")
170 struct window
*w
= decode_window (window
);
171 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
174 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
175 Spos_visible_in_window_p
, 0, 2, 0,
176 "Return t if position POS is currently on the frame in WINDOW.\n\
177 Returns nil if that position is scrolled vertically out of view.\n\
178 POS defaults to point; WINDOW, to the selected window.")
180 Lisp_Object pos
, window
;
182 register struct window
*w
;
186 register struct buffer
*buf
;
187 struct position posval
;
193 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
197 w
= decode_window (window
);
198 top
= marker_position (w
->start
);
203 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
205 buf
= XBUFFER (w
->buffer
);
206 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
208 /* If frame is up to date,
209 use the info recorded about how much text fit on it. */
210 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
211 || (XFASTINT (w
->window_end_vpos
) < height
))
217 if (posint
> BUF_Z (buf
))
220 /* If that info is not correct, calculate afresh */
221 posval
= *compute_motion (top
, 0, 0, posint
, height
, 0,
222 window_internal_width (w
) - 1,
223 XINT (w
->hscroll
), 0);
225 return posval
.vpos
< height
? Qt
: Qnil
;
229 static struct window
*
230 decode_window (window
)
231 register Lisp_Object window
;
234 return XWINDOW (selected_window
);
236 CHECK_LIVE_WINDOW (window
, 0);
237 return XWINDOW (window
);
240 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
241 "Return the buffer that WINDOW is displaying.")
245 return decode_window (window
)->buffer
;
248 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
249 "Return the number of lines in WINDOW (including its mode line).")
253 return decode_window (window
)->height
;
256 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
257 "Return the number of columns in WINDOW.")
261 register struct window
*w
= decode_window (window
);
262 register int width
= XFASTINT (w
->width
);
264 return make_number (window_internal_width (w
));
267 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
268 "Return the number of columns by which WINDOW is scrolled from left margin.")
272 return decode_window (window
)->hscroll
;
275 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
276 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
277 NCOL should be zero or positive.")
279 register Lisp_Object window
, ncol
;
281 register struct window
*w
;
283 CHECK_NUMBER (ncol
, 1);
284 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
285 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
286 args_out_of_range (ncol
, Qnil
);
287 w
= decode_window (window
);
288 if (XINT (w
->hscroll
) != XINT (ncol
))
289 clip_changed
= 1; /* Prevent redisplay shortcuts */
294 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
295 "Return a list of the edge coordinates of WINDOW.\n\
296 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
297 RIGHT is one more than the rightmost column used by WINDOW,\n\
298 and BOTTOM is one more than the bottommost row used by WINDOW\n\
303 register struct window
*w
= decode_window (window
);
305 return Fcons (w
->left
, Fcons (w
->top
,
306 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
307 Fcons (make_number (XFASTINT (w
->top
)
308 + XFASTINT (w
->height
)),
312 /* Test if the character at column *x, row *y is within window *w.
313 If it is not, return 0;
314 if it is in the window's text area,
315 set *x and *y to its location relative to the upper left corner
318 if it is on the window's modeline, return 2;
319 if it is on the border between the window and its right sibling,
322 coordinates_in_window (w
, x
, y
)
323 register struct window
*w
;
326 register int left
= XINT (w
->left
);
327 register int width
= XINT (w
->width
);
328 register int window_height
= XINT (w
->height
);
329 register int top
= XFASTINT (w
->top
);
331 if ( *x
< left
|| *x
>= left
+ width
332 || *y
< top
|| *y
>= top
+ window_height
)
335 /* Is the character is the mode line? */
336 if (*y
== top
+ window_height
- 1
337 && ! MINI_WINDOW_P (w
))
340 /* Is the character in the right border? */
341 if (*x
== left
+ width
- 1
342 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
350 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
351 Scoordinates_in_window_p
, 2, 2, 0,
352 "Return non-nil if COORDINATES are in WINDOW.\n\
353 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
354 measured in characters from the upper-left corner of the frame.\n\
355 (0 . 0) denotes the character in the upper left corner of the\n\
357 If COORDINATES are in the text portion of WINDOW,\n\
358 the coordinates relative to the window are returned.\n\
359 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
360 If they are on the border between WINDOW and its right sibling,\n\
361 `vertical-line' is returned.")
362 (coordinates
, window
)
363 register Lisp_Object coordinates
, window
;
367 CHECK_LIVE_WINDOW (window
, 0);
368 CHECK_CONS (coordinates
, 1);
369 x
= XINT (Fcar (coordinates
));
370 y
= XINT (Fcdr (coordinates
));
372 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
374 case 0: /* NOT in window at all. */
377 case 1: /* In text part of window. */
380 case 2: /* In mode line of window. */
383 case 3: /* On right border of window. */
384 return Qvertical_line
;
391 /* Find the window containing column x, row y, and return it as a
392 Lisp_Object. If x, y is on the window's modeline, set *part
393 to 1; if it is on the separating line between the window and its
394 right sibling, set it to 2; otherwise set it to 0. If there is no
395 window under x, y return nil and leave *part unmodified. */
397 window_from_coordinates (frame
, x
, y
, part
)
402 register Lisp_Object tem
, first
;
404 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
408 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
416 tem
= Fnext_window (tem
, Qt
, Qlambda
);
418 while (! EQ (tem
, first
));
423 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
424 "Return window containing coordinates X and Y on FRAME.\n\
425 If omitted, FRAME defaults to the currently selected frame.\n\
426 The top left corner of the frame is considered to be row 0,\n\
429 Lisp_Object x
, y
, frame
;
435 XSET (frame
, Lisp_Frame
, selected_frame
);
437 CHECK_LIVE_FRAME (frame
, 2);
442 return window_from_coordinates (XFRAME (frame
),
447 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
448 "Return current value of point in WINDOW.\n\
449 For a nonselected window, this is the value point would have\n\
450 if that window were selected.\n\
452 Note that, when WINDOW is the selected window and its buffer\n\
453 is also currently selected, the value returned is the same as (point).\n\
454 It would be more strictly correct to return the `top-level' value\n\
455 of point, outside of any save-excursion forms.\n\
456 But that is hard to define.")
460 register struct window
*w
= decode_window (window
);
462 if (w
== XWINDOW (selected_window
)
463 && current_buffer
== XBUFFER (w
->buffer
))
465 return Fmarker_position (w
->pointm
);
468 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
469 "Return position at which display currently starts in WINDOW.")
473 return Fmarker_position (decode_window (window
)->start
);
476 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
477 "Return position at which display currently ends in WINDOW.")
482 struct window
*w
= decode_window (window
);
484 XSET (value
, Lisp_Int
,
485 BUF_Z (current_buffer
) - XFASTINT (w
->window_end_pos
));
490 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
491 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
493 Lisp_Object window
, pos
;
495 register struct window
*w
= decode_window (window
);
497 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
498 if (w
== XWINDOW (selected_window
))
501 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
506 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
507 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
508 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
509 from overriding motion of point in order to display at this exact start.")
510 (window
, pos
, noforce
)
511 Lisp_Object window
, pos
, noforce
;
513 register struct window
*w
= decode_window (window
);
515 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
516 set_marker_restricted (w
->start
, pos
, w
->buffer
);
517 /* this is not right, but much easier than doing what is right. */
518 w
->start_at_line_beg
= Qnil
;
521 w
->update_mode_line
= Qt
;
522 XFASTINT (w
->last_modified
) = 0;
523 if (!EQ (window
, selected_window
))
524 windows_or_buffers_changed
++;
528 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
530 "Return WINDOW's dedicated object, usually t or nil.\n\
531 See also `set-window-dedicated-p'.")
535 return decode_window (window
)->dedicated
;
538 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
539 Sset_window_dedicated_p
, 2, 2, 0,
540 "Control whether WINDOW is dedicated to the buffer it displays.\n\
541 If it is dedicated, Emacs will not automatically change\n\
542 which buffer appears in it.\n\
543 The second argument is the new value for the dedication flag;\n\
546 Lisp_Object window
, arg
;
548 register struct window
*w
= decode_window (window
);
558 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
560 "Return the display-table that WINDOW is using.")
564 return decode_window (window
)->display_table
;
567 /* Get the display table for use currently on window W.
568 This is either W's display table or W's buffer's display table.
569 Ignore the specified tables if they are not valid;
570 if no valid table is specified, return 0. */
573 window_display_table (w
)
577 tem
= w
->display_table
;
578 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
579 return XVECTOR (tem
);
580 tem
= XBUFFER (w
->buffer
)->display_table
;
581 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
582 return XVECTOR (tem
);
583 tem
= Vstandard_display_table
;
584 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
585 return XVECTOR (tem
);
589 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
590 "Set WINDOW's display-table to TABLE.")
592 register Lisp_Object window
, table
;
594 register struct window
*w
;
595 register Lisp_Object z
; /* Return value. */
597 w
= decode_window (window
);
598 w
->display_table
= table
;
602 /* Record info on buffer window w is displaying
603 when it is about to cease to display that buffer. */
606 register struct window
*w
;
608 Lisp_Object buf
= w
->buffer
;
610 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
613 if (w
== XWINDOW (selected_window
)
614 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
615 /* Do this except when the selected window's buffer
616 is being removed from some other window. */
617 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
619 /* Point in the selected window's buffer
620 is actually stored in that buffer, and the window's pointm isn't used.
621 So don't clobber point in that buffer. */
622 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
623 BUF_PT (XBUFFER (buf
))
624 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
625 marker_position (w
->pointm
),
626 BUF_ZV (XBUFFER (buf
)));
629 /* Put replacement into the window structure in place of old. */
631 replace_window (old
, replacement
)
632 Lisp_Object old
, replacement
;
634 register Lisp_Object tem
;
635 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
637 /* If OLD is its frame's root_window, then replacement is the new
638 root_window for that frame. */
640 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
641 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
646 p
->height
= o
->height
;
648 p
->next
= tem
= o
->next
;
650 XWINDOW (tem
)->prev
= replacement
;
652 p
->prev
= tem
= o
->prev
;
654 XWINDOW (tem
)->next
= replacement
;
656 p
->parent
= tem
= o
->parent
;
659 if (EQ (XWINDOW (tem
)->vchild
, old
))
660 XWINDOW (tem
)->vchild
= replacement
;
661 if (EQ (XWINDOW (tem
)->hchild
, old
))
662 XWINDOW (tem
)->hchild
= replacement
;
665 /*** Here, if replacement is a vertical combination
666 and so is its new parent, we should make replacement's
667 children be children of that parent instead. ***/
670 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
671 "Remove WINDOW from the display. Default is selected window.")
673 register Lisp_Object window
;
675 register Lisp_Object tem
, parent
, sib
;
676 register struct window
*p
;
677 register struct window
*par
;
679 /* Because this function is called by other C code on non-leaf
680 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
681 so we can't decode_window here. */
683 window
= selected_window
;
685 CHECK_WINDOW (window
, 0);
686 p
= XWINDOW (window
);
688 /* It's okay to delete an already-deleted window. */
696 error ("Attempt to delete minibuffer or sole ordinary window");
697 par
= XWINDOW (parent
);
699 windows_or_buffers_changed
++;
701 /* Are we trying to delete any frame's selected window? */
703 Lisp_Object frame
, pwindow
;
705 /* See if the frame's selected window is either WINDOW
706 or any subwindow of it, by finding all that window's parents
707 and comparing each one with WINDOW. */
708 frame
= WINDOW_FRAME (XWINDOW (window
));
709 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
711 while (!NILP (pwindow
))
713 if (EQ (window
, pwindow
))
715 pwindow
= XWINDOW (pwindow
)->parent
;
718 if (EQ (window
, pwindow
))
720 Lisp_Object alternative
= Fnext_window (window
, Qlambda
, Qnil
);
722 /* If we're about to delete the selected window on the
723 selected frame, then we should use Fselect_window to select
724 the new window. On the other hand, if we're about to
725 delete the selected window on any other frame, we shouldn't do
726 anything but set the frame's selected_window slot. */
727 if (EQ (window
, selected_window
))
728 Fselect_window (alternative
);
730 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
735 /* tem is null for dummy parent windows
736 (which have inferiors but not any contents themselves) */
740 unchain_marker (p
->pointm
);
741 unchain_marker (p
->start
);
746 XWINDOW (tem
)->prev
= p
->prev
;
750 XWINDOW (tem
)->next
= p
->next
;
752 if (EQ (window
, par
->hchild
))
753 par
->hchild
= p
->next
;
754 if (EQ (window
, par
->vchild
))
755 par
->vchild
= p
->next
;
757 /* Find one of our siblings to give our space to. */
761 /* If p gives its space to its next sibling, that sibling needs
762 to have its top/left side pulled back to where p's is.
763 set_window_{height,width} will re-position the sibling's
766 XWINDOW (sib
)->top
= p
->top
;
767 XWINDOW (sib
)->left
= p
->left
;
770 /* Stretch that sibling. */
771 if (!NILP (par
->vchild
))
772 set_window_height (sib
,
773 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
775 if (!NILP (par
->hchild
))
776 set_window_width (sib
,
777 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
780 /* If parent now has only one child,
781 put the child into the parent's place. */
785 if (NILP (XWINDOW (tem
)->next
))
786 replace_window (parent
, tem
);
788 /* Since we may be deleting combination windows, we must make sure that
789 not only p but all its children have been marked as deleted. */
790 if (! NILP (p
->hchild
))
791 delete_all_subwindows (XWINDOW (p
->hchild
));
792 else if (! NILP (p
->vchild
))
793 delete_all_subwindows (XWINDOW (p
->vchild
));
795 /* Mark this window as deleted. */
796 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
802 extern Lisp_Object
next_frame (), prev_frame ();
804 /* This comment supplies the doc string for `next-window',
805 for make-docfile to see. We cannot put this in the real DEFUN
806 due to limits in the Unix cpp.
808 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
809 "Return next window after WINDOW in canonical ordering of windows.\n\
810 If omitted, WINDOW defaults to the selected window.\n\
812 Optional second arg MINIBUF t means count the minibuffer window even\n\
813 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
814 it is active. MINIBUF neither t nor nil means not to count the\n\
815 minibuffer even if it is active.\n\
817 Several frames may share a single minibuffer; if the minibuffer\n\
818 counts, all windows on all frames that share that minibuffer count\n\
819 too. This means that next-window may be used to iterate through the\n\
820 set of windows even when the minibuffer is on another frame. If the\n\
821 minibuffer does not count, only windows from WINDOW's frame count.\n\
823 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
824 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
825 above. If neither nil nor t, restrict to WINDOW's frame.\n\
827 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
828 `next-window' to iterate through the entire cycle of acceptable\n\
829 windows, eventually ending up back at the window you started with.\n\
830 `previous-window' traverses the same cycle, in the reverse order.")
831 (window, minibuf, all_frames) */
833 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
835 (window
, minibuf
, all_frames
)
836 register Lisp_Object window
, minibuf
, all_frames
;
838 register Lisp_Object tem
;
839 Lisp_Object start_window
;
842 window
= selected_window
;
844 CHECK_LIVE_WINDOW (window
, 0);
846 start_window
= window
;
848 /* minibuf == nil may or may not include minibuffers.
849 Decide if it does. */
851 minibuf
= (minibuf_level
? Qt
: Qlambda
);
853 /* all_frames == nil doesn't specify which frames to include.
854 Decide which frames it includes. */
855 if (NILP (all_frames
))
856 all_frames
= (EQ (minibuf
, Qt
)
857 ? (FRAME_MINIBUF_WINDOW
860 (XWINDOW (window
)))))
862 else if (! EQ (all_frames
, Qt
))
864 /* Now all_frames is t meaning search all frames,
865 nil meaning search just current frame,
866 or a window, meaning search the frame that window belongs to. */
868 /* Do this loop at least once, to get the next window, and perhaps
869 again, if we hit the minibuffer and that is not acceptable. */
872 /* Find a window that actually has a next one. This loop
873 climbs up the tree. */
874 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
875 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
879 /* We've reached the end of this frame.
880 Which other frames are acceptable? */
881 tem
= WINDOW_FRAME (XWINDOW (window
));
883 if (! NILP (all_frames
))
884 tem
= next_frame (tem
, all_frames
);
886 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
893 /* If we're in a combination window, find its first child and
894 recurse on that. Otherwise, we've found the window we want. */
897 if (!NILP (XWINDOW (window
)->hchild
))
898 window
= XWINDOW (window
)->hchild
;
899 else if (!NILP (XWINDOW (window
)->vchild
))
900 window
= XWINDOW (window
)->vchild
;
904 /* Which windows are acceptible?
905 Exit the loop and accept this window if
906 this isn't a minibuffer window, or
907 we're accepting minibuffer windows, or
908 we've come all the way around and we're back at the original window. */
909 while (MINI_WINDOW_P (XWINDOW (window
))
910 && ! EQ (minibuf
, Qt
)
911 && ! EQ (window
, start_window
));
916 /* This comment supplies the doc string for `previous-window',
917 for make-docfile to see. We cannot put this in the real DEFUN
918 due to limits in the Unix cpp.
920 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
921 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
922 If omitted, WINDOW defaults to the selected window.\n\
924 Optional second arg MINIBUF t means count the minibuffer window even\n\
925 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
926 it is active. MINIBUF neither t nor nil means not to count the\n\
927 minibuffer even if it is active.\n\
929 Several frames may share a single minibuffer; if the minibuffer\n\
930 counts, all windows on all frames that share that minibuffer count\n\
931 too. This means that previous-window may be used to iterate through\n\
932 the set of windows even when the minibuffer is on another frame. If\n\
933 the minibuffer does not count, only windows from WINDOW's frame\n\
936 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
937 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
938 above. If neither nil nor t, restrict to WINDOW's frame.\n\
940 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
941 `previous-window' to iterate through the entire cycle of acceptable\n\
942 windows, eventually ending up back at the window you started with.\n\
943 `next-window' traverses the same cycle, in the reverse order.")
944 (window, minibuf, all_frames) */
947 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
949 (window
, minibuf
, all_frames
)
950 register Lisp_Object window
, minibuf
, all_frames
;
952 register Lisp_Object tem
;
953 Lisp_Object start_window
;
956 window
= selected_window
;
958 CHECK_LIVE_WINDOW (window
, 0);
960 start_window
= window
;
962 /* minibuf == nil may or may not include minibuffers.
963 Decide if it does. */
965 minibuf
= (minibuf_level
? Qt
: Qlambda
);
967 /* all_frames == nil doesn't specify which frames to include.
968 Decide which frames it includes. */
969 if (NILP (all_frames
))
970 all_frames
= (EQ (minibuf
, Qt
)
971 ? (FRAME_MINIBUF_WINDOW
974 (XWINDOW (window
)))))
976 else if (! EQ (all_frames
, Qt
))
978 /* Now all_frames is t meaning search all frames,
979 nil meaning search just current frame,
980 or a window, meaning search the frame that window belongs to. */
982 /* Do this loop at least once, to get the previous window, and perhaps
983 again, if we hit the minibuffer and that is not acceptable. */
986 /* Find a window that actually has a previous one. This loop
987 climbs up the tree. */
988 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
989 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
993 /* We have found the top window on the frame.
994 Which frames are acceptable? */
995 tem
= WINDOW_FRAME (XWINDOW (window
));
997 if (! NILP (all_frames
))
998 /* It's actually important that we use prev_frame here,
999 rather than next_frame. All the windows acceptable
1000 according to the given parameters should form a ring;
1001 Fnext_window and Fprevious_window should go back and
1002 forth around the ring. If we use next_frame here,
1003 then Fnext_window and Fprevious_window take different
1004 paths through the set of acceptable windows.
1005 window_loop assumes that these `ring' requirement are
1007 tem
= prev_frame (tem
, all_frames
);
1009 /* If this frame has a minibuffer, find that window first,
1010 because it is conceptually the last window in that frame. */
1011 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1012 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1014 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1020 /* If we're in a combination window, find its last child and
1021 recurse on that. Otherwise, we've found the window we want. */
1024 if (!NILP (XWINDOW (window
)->hchild
))
1025 window
= XWINDOW (window
)->hchild
;
1026 else if (!NILP (XWINDOW (window
)->vchild
))
1027 window
= XWINDOW (window
)->vchild
;
1029 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1033 /* Which windows are acceptable?
1034 Exit the loop and accept this window if
1035 this isn't a minibuffer window, or
1036 we're accepting minibuffer windows, or
1037 we've come all the way around and we're back at the original window. */
1038 while (MINI_WINDOW_P (XWINDOW (window
))
1039 && !EQ (minibuf
, Qt
)
1040 && !EQ (window
, start_window
));
1045 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1046 "Select the ARG'th different window on this frame.\n\
1047 All windows on current frame are arranged in a cyclic order.\n\
1048 This command selects the window ARG steps away in that order.\n\
1049 A negative ARG moves in the opposite order. If the optional second\n\
1050 argument ALL_FRAMES is non-nil, cycle through all frames.")
1052 register Lisp_Object n
, all_frames
;
1055 register Lisp_Object w
;
1057 CHECK_NUMBER (n
, 0);
1058 w
= selected_window
;
1063 w
= Fnext_window (w
, Qnil
, all_frames
);
1068 w
= Fprevious_window (w
, Qnil
, all_frames
);
1075 /* Look at all windows, performing an operation specified by TYPE
1077 If FRAMES is Qt, look at all frames;
1078 Qnil, look at just the selected frame;
1079 a frame, just look at windows on that frame.
1080 If MINI is non-zero, perform the operation on minibuffer windows too.
1086 GET_BUFFER_WINDOW
, /* Arg is buffer */
1087 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1088 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1089 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1091 UNSHOW_BUFFER
, /* Arg is buffer */
1095 window_loop (type
, obj
, mini
, frames
)
1096 enum window_loop type
;
1097 register Lisp_Object obj
, frames
;
1100 register Lisp_Object w
;
1101 register Lisp_Object best_window
;
1102 register Lisp_Object next_window
;
1103 register Lisp_Object last_window
;
1107 /* If we're only looping through windows on a particular frame,
1108 frame points to that frame. If we're looping through windows
1109 on all frames, frame is 0. */
1110 if (FRAMEP (frames
))
1111 frame
= XFRAME (frames
);
1112 else if (NILP (frames
))
1113 frame
= selected_frame
;
1120 /* Pick a window to start with. */
1121 if (XTYPE (obj
) == Lisp_Window
)
1124 w
= FRAME_SELECTED_WINDOW (frame
);
1126 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1128 /* Figure out the last window we're going to mess with. Since
1129 Fnext_window, given the same options, is guaranteed to go in a
1130 ring, we can just use Fprevious_window to find the last one.
1132 We can't just wait until we hit the first window again, because
1133 it might be deleted. */
1137 last_window
= Fprevious_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1139 #endif /* MULTI_FRAME */
1140 /* We know frame is 0, so we're looping through all frames.
1141 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1142 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, Qt
);
1147 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1149 /* Pick the next window now, since some operations will delete
1150 the current window. */
1153 next_window
= Fnext_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1155 #endif /* MULTI_FRAME */
1156 /* We know frame is 0, so we're looping through all frames.
1157 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1158 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, Qt
);
1160 if (! MINI_WINDOW_P (XWINDOW (w
))
1161 || (mini
&& minibuf_level
> 0))
1164 case GET_BUFFER_WINDOW
:
1165 /* Ignore invisible and iconified frames. */
1166 if (! FRAME_VISIBLE_P (w_frame
)
1167 || FRAME_ICONIFIED_P (w_frame
))
1169 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1173 case GET_LRU_WINDOW
:
1174 /* t as arg means consider only full-width windows */
1175 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1176 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1179 /* Ignore invisible and iconified frames. */
1180 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1181 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1184 /* Ignore dedicated windows and minibuffers. */
1185 if (MINI_WINDOW_P (XWINDOW (w
))
1186 || !NILP (XWINDOW (w
)->dedicated
))
1188 if (NILP (best_window
)
1189 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1190 > XFASTINT (XWINDOW (w
)->use_time
)))
1194 case DELETE_OTHER_WINDOWS
:
1195 if (XWINDOW (w
) != XWINDOW (obj
))
1199 case DELETE_BUFFER_WINDOWS
:
1200 if (EQ (XWINDOW (w
)->buffer
, obj
))
1202 /* If we're deleting the buffer displayed in the only window
1203 on the frame, find a new buffer to display there. */
1204 if (NILP (XWINDOW (w
)->parent
))
1206 Lisp_Object new_buffer
= Fother_buffer (obj
, Qnil
);
1207 if (NILP (new_buffer
))
1209 = Fget_buffer_create (build_string ("*scratch*"));
1210 Fset_window_buffer (w
, new_buffer
);
1211 Fset_buffer (XWINDOW (w
)->buffer
);
1218 case GET_LARGEST_WINDOW
:
1220 /* Ignore invisible and iconified frames. */
1221 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1222 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1225 /* Ignore dedicated windows and minibuffers. */
1226 if (MINI_WINDOW_P (XWINDOW (w
))
1227 || !NILP (XWINDOW (w
)->dedicated
))
1230 struct window
*best_window_ptr
= XWINDOW (best_window
);
1231 struct window
*w_ptr
= XWINDOW (w
);
1232 if (NILP (best_window
) ||
1233 (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
))
1234 > (XFASTINT (best_window_ptr
->height
)
1235 * XFASTINT (best_window_ptr
->width
)))
1241 if (EQ (XWINDOW (w
)->buffer
, obj
))
1243 /* Find another buffer to show in this window. */
1244 Lisp_Object another_buffer
= Fother_buffer (obj
, Qnil
);
1245 if (NILP (another_buffer
))
1247 = Fget_buffer_create (build_string ("*scratch*"));
1248 Fset_window_buffer (w
, another_buffer
);
1249 if (EQ (w
, selected_window
))
1250 Fset_buffer (XWINDOW (w
)->buffer
);
1255 if (EQ (w
, last_window
))
1264 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1265 "Return the window least recently selected or used for display.\n\
1266 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1267 frame, search only that frame.\n")
1271 register Lisp_Object w
;
1272 /* First try for a window that is full-width */
1273 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frames
);
1274 if (!NILP (w
) && !EQ (w
, selected_window
))
1276 /* If none of them, try the rest */
1277 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frames
);
1280 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1281 "Return the largest window in area.\n\
1282 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1283 frame, search only that frame.\n")
1287 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1291 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1292 "Return a window currently displaying BUFFER, or nil if none.\n\
1293 If optional argument FRAME is t, search all visible frames.\n\
1294 If FRAME is nil, search only the selected frame.\n\
1295 If FRAME is a frame, search only that frame.\n")
1297 Lisp_Object buffer
, frame
;
1299 buffer
= Fget_buffer (buffer
);
1300 if (XTYPE (buffer
) == Lisp_Buffer
)
1301 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1306 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1308 "Make WINDOW (or the selected window) fill its frame.\n\
1309 Only the frame WINDOW is on is affected.")
1315 struct buffer
*obuf
= current_buffer
;
1319 window
= selected_window
;
1321 CHECK_LIVE_WINDOW (window
, 0);
1323 w
= XWINDOW (window
);
1324 top
= XFASTINT (w
->top
);
1326 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1328 Fset_buffer (w
->buffer
);
1329 SET_PT (marker_position (w
->start
));
1330 Frecenter (make_number (top
- FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)))));
1332 set_buffer_internal (obuf
);
1337 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1338 1, 1, "bDelete windows on (buffer): ",
1339 "Delete all windows showing BUFFER.\n\
1340 Optional second argument FRAME controls which frames are affected.\n\
1341 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1342 If t, delete only windows showing BUFFER in the selected frame.\n\
1343 If a frame, delete only windows showing BUFFER in that frame.")
1345 Lisp_Object buffer
, frame
;
1348 /* FRAME uses t and nil to mean the opposite of what window_loop
1350 if (! FRAMEP (frame
))
1351 frame
= NILP (frame
) ? Qt
: Qnil
;
1358 buffer
= Fget_buffer (buffer
);
1359 CHECK_BUFFER (buffer
, 0);
1360 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1365 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1366 Sreplace_buffer_in_windows
,
1367 1, 1, "bReplace buffer in windows: ",
1368 "Replace BUFFER with some other buffer in all windows showing it.")
1374 buffer
= Fget_buffer (buffer
);
1375 CHECK_BUFFER (buffer
, 0);
1376 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1381 /* Set the height of WINDOW and all its inferiors. */
1383 /* The smallest acceptable dimensions for a window. Anything smaller
1384 might crash Emacs. */
1385 #define MIN_SAFE_WINDOW_WIDTH (2)
1386 #define MIN_SAFE_WINDOW_HEIGHT (2)
1388 /* Make sure that window_min_height and window_min_width are
1389 not too small; if they are, set them to safe minima. */
1392 check_min_window_sizes ()
1394 /* Smaller values might permit a crash. */
1395 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1396 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1397 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1398 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1401 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1402 minimum allowable size. */
1404 check_frame_size (frame
, rows
, cols
)
1408 /* For height, we have to see whether the frame has a minibuffer, and
1409 whether it wants a mode line. */
1411 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1412 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1413 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1415 if (*rows
< min_height
)
1417 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1418 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1421 /* Normally the window is deleted if it gets too small.
1422 nodelete nonzero means do not do this.
1423 (The caller should check later and do so if appropriate) */
1425 set_window_height (window
, height
, nodelete
)
1430 register struct window
*w
= XWINDOW (window
);
1431 register struct window
*c
;
1432 int oheight
= XFASTINT (w
->height
);
1433 int top
, pos
, lastbot
, opos
, lastobot
;
1436 check_min_window_sizes ();
1439 && ! NILP (w
->parent
)
1440 && height
< window_min_height
)
1442 Fdelete_window (window
);
1446 XFASTINT (w
->last_modified
) = 0;
1447 windows_or_buffers_changed
++;
1448 XFASTINT (w
->height
) = height
;
1449 if (!NILP (w
->hchild
))
1451 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1453 XWINDOW (child
)->top
= w
->top
;
1454 set_window_height (child
, height
, nodelete
);
1457 else if (!NILP (w
->vchild
))
1459 lastbot
= top
= XFASTINT (w
->top
);
1461 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1463 c
= XWINDOW (child
);
1465 opos
= lastobot
+ XFASTINT (c
->height
);
1467 XFASTINT (c
->top
) = lastbot
;
1469 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1471 /* Avoid confusion: inhibit deletion of child if becomes too small */
1472 set_window_height (child
, pos
+ top
- lastbot
, 1);
1474 /* Now advance child to next window,
1475 and set lastbot if child was not just deleted. */
1476 lastbot
= pos
+ top
;
1479 /* Now delete any children that became too small. */
1481 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1483 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1488 /* Recursively set width of WINDOW and its inferiors. */
1490 set_window_width (window
, width
, nodelete
)
1495 register struct window
*w
= XWINDOW (window
);
1496 register struct window
*c
;
1497 int owidth
= XFASTINT (w
->width
);
1498 int left
, pos
, lastright
, opos
, lastoright
;
1501 if (!nodelete
&& width
< window_min_width
)
1503 Fdelete_window (window
);
1507 XFASTINT (w
->last_modified
) = 0;
1508 windows_or_buffers_changed
++;
1509 XFASTINT (w
->width
) = width
;
1510 if (!NILP (w
->vchild
))
1512 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1514 XWINDOW (child
)->left
= w
->left
;
1515 set_window_width (child
, width
, nodelete
);
1518 else if (!NILP (w
->hchild
))
1520 lastright
= left
= XFASTINT (w
->left
);
1522 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1524 c
= XWINDOW (child
);
1526 opos
= lastoright
+ XFASTINT (c
->width
);
1528 XFASTINT (c
->left
) = lastright
;
1530 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1532 /* Inhibit deletion for becoming too small */
1533 set_window_width (child
, pos
+ left
- lastright
, 1);
1535 /* Now advance child to next window,
1536 and set lastright if child was not just deleted. */
1537 lastright
= pos
+ left
, lastoright
= opos
;
1539 /* Delete children that became too small */
1541 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1543 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1548 int window_select_count
;
1550 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1551 "Make WINDOW display BUFFER as its contents.\n\
1552 BUFFER can be a buffer or buffer name.")
1554 register Lisp_Object window
, buffer
;
1556 register Lisp_Object tem
;
1557 register struct window
*w
= decode_window (window
);
1559 buffer
= Fget_buffer (buffer
);
1560 CHECK_BUFFER (buffer
, 1);
1562 if (NILP (XBUFFER (buffer
)->name
))
1563 error ("Attempt to display deleted buffer");
1567 error ("Window is deleted");
1568 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1569 is first being set up. */
1571 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1572 error ("Window is dedicated to %s\n", tem
);
1579 Fset_marker (w
->pointm
,
1580 make_number (BUF_PT (XBUFFER (buffer
))),
1582 set_marker_restricted (w
->start
,
1583 make_number (XBUFFER (buffer
)->last_window_start
),
1585 w
->start_at_line_beg
= Qnil
;
1586 w
->force_start
= Qnil
;
1587 XFASTINT (w
->last_modified
) = 0;
1588 windows_or_buffers_changed
++;
1589 if (EQ (window
, selected_window
))
1590 Fset_buffer (buffer
);
1595 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1596 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1597 The main editor command loop selects the buffer of the selected window\n\
1598 before each command.")
1600 register Lisp_Object window
;
1602 register struct window
*w
;
1603 register struct window
*ow
= XWINDOW (selected_window
);
1605 CHECK_LIVE_WINDOW (window
, 0);
1607 w
= XWINDOW (window
);
1609 if (NILP (w
->buffer
))
1610 error ("Trying to select deleted window or non-leaf window");
1612 XFASTINT (w
->use_time
) = ++window_select_count
;
1613 if (EQ (window
, selected_window
))
1616 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1619 selected_window
= window
;
1621 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1623 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1624 Fhandle_switch_frame (WINDOW_FRAME (w
), Qnil
);
1627 selected_frame
->selected_window
= window
;
1630 record_buffer (w
->buffer
);
1631 Fset_buffer (w
->buffer
);
1633 /* Go to the point recorded in the window.
1634 This is important when the buffer is in more
1635 than one window. It also matters when
1636 redisplay_window has altered point after scrolling,
1637 because it makes the change only in the window. */
1639 register int new_point
= marker_position (w
->pointm
);
1640 if (new_point
< BEGV
)
1648 windows_or_buffers_changed
++;
1652 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1653 "BDisplay buffer: \nP",
1654 "Make BUFFER appear in some window but don't select it.\n\
1655 BUFFER can be a buffer or a buffer name.\n\
1656 If BUFFER is shown already in some window, just use that one,\n\
1657 unless the window is the selected window and the optional second\n\
1658 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1659 Returns the window displaying BUFFER.")
1660 (buffer
, not_this_window
)
1661 register Lisp_Object buffer
, not_this_window
;
1663 register Lisp_Object window
;
1665 buffer
= Fget_buffer (buffer
);
1666 CHECK_BUFFER (buffer
, 0);
1668 if (!NILP (Vdisplay_buffer_function
))
1669 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1671 if (NILP (not_this_window
)
1672 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1673 return selected_window
;
1675 window
= Fget_buffer_window (buffer
, Qnil
);
1677 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1681 /* If there are no frames open that have more than a minibuffer,
1682 we need to create a new frame. */
1683 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1686 = Fframe_selected_window (call0 (Vpop_up_frame_function
));
1687 Fset_window_buffer (window
, buffer
);
1689 Fhandle_switch_frame (XWINDOW (window
)->frame
, Qnil
);
1693 #endif /* MULTI_FRAME */
1697 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1701 Lisp_Object frames
= Qnil
;
1704 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1705 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1707 /* Don't try to create a window if would get an error */
1708 if (split_height_threshold
< window_min_height
<< 1)
1709 split_height_threshold
= window_min_height
<< 1;
1711 window
= Fget_largest_window (frames
);
1714 && window_height (window
) >= split_height_threshold
1715 && (XFASTINT (XWINDOW (window
)->width
)
1716 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1717 window
= Fsplit_window (window
, Qnil
, Qnil
);
1720 window
= Fget_lru_window (frames
);
1721 if ((EQ (window
, selected_window
)
1722 || EQ (XWINDOW (window
)->parent
, Qnil
))
1723 && window_height (window
) >= window_min_height
<< 1)
1724 window
= Fsplit_window (window
, Qnil
, Qnil
);
1728 window
= Fget_lru_window (Qnil
);
1730 Fset_window_buffer (window
, buffer
);
1735 temp_output_buffer_show (buf
)
1736 register Lisp_Object buf
;
1738 register struct buffer
*old
= current_buffer
;
1739 register Lisp_Object window
;
1740 register struct window
*w
;
1743 XBUFFER (buf
)->save_modified
= MODIFF
;
1748 set_buffer_internal (old
);
1750 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1751 call1 (Vtemp_buffer_show_function
, buf
);
1754 window
= Fdisplay_buffer (buf
, Qnil
);
1757 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1758 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1759 #endif /* MULTI_FRAME */
1760 Vminibuf_scroll_window
= window
;
1761 w
= XWINDOW (window
);
1762 XFASTINT (w
->hscroll
) = 0;
1763 set_marker_restricted (w
->start
, make_number (1), buf
);
1764 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1769 make_dummy_parent (window
)
1772 register Lisp_Object old
, new;
1773 register struct window
*o
, *p
;
1776 XSETTYPE (old
, Lisp_Vector
);
1777 new = Fcopy_sequence (old
);
1778 XSETTYPE (new, Lisp_Window
);
1782 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1784 /* Put new into window structure in place of window */
1785 replace_window (window
, new);
1798 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1799 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1800 WINDOW defaults to selected one and SIZE to half its size.\n\
1801 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1802 and put SIZE columns in the first of the pair.")
1803 (window
, chsize
, horflag
)
1804 Lisp_Object window
, chsize
, horflag
;
1806 register Lisp_Object
new;
1807 register struct window
*o
, *p
;
1811 window
= selected_window
;
1813 CHECK_LIVE_WINDOW (window
, 0);
1815 o
= XWINDOW (window
);
1819 if (!NILP (horflag
))
1820 /* Round odd size up, since this is for the left-hand window,
1821 and it will lose a column for the separators. */
1822 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1824 size
= XFASTINT (o
->height
) >> 1;
1828 CHECK_NUMBER (chsize
, 1);
1829 size
= XINT (chsize
);
1832 if (MINI_WINDOW_P (o
))
1833 error ("Attempt to split minibuffer window");
1834 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1835 error ("Attempt to split unsplittable frame");
1837 check_min_window_sizes ();
1841 if (size
< window_min_height
1842 || size
+ window_min_height
> XFASTINT (o
->height
))
1843 args_out_of_range_3 (window
, chsize
, horflag
);
1844 if (NILP (o
->parent
)
1845 || NILP (XWINDOW (o
->parent
)->vchild
))
1847 make_dummy_parent (window
);
1849 XWINDOW (new)->vchild
= window
;
1854 if (size
< window_min_width
1855 || size
+ window_min_width
> XFASTINT (o
->width
))
1856 args_out_of_range_3 (window
, chsize
, horflag
);
1857 if (NILP (o
->parent
)
1858 || NILP (XWINDOW (o
->parent
)->hchild
))
1860 make_dummy_parent (window
);
1862 XWINDOW (new)->hchild
= window
;
1866 /* Now we know that window's parent is a vertical combination
1867 if we are dividing vertically, or a horizontal combination
1868 if we are making side-by-side windows */
1870 windows_or_buffers_changed
++;
1871 new = make_window ();
1874 p
->frame
= o
->frame
;
1876 if (!NILP (p
->next
))
1877 XWINDOW (p
->next
)->prev
= new;
1880 p
->parent
= o
->parent
;
1883 Fset_window_buffer (new, o
->buffer
);
1885 /* Apportion the available frame space among the two new windows */
1887 if (!NILP (horflag
))
1889 p
->height
= o
->height
;
1891 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1892 XFASTINT (o
->width
) = size
;
1893 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1898 p
->width
= o
->width
;
1899 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1900 XFASTINT (o
->height
) = size
;
1901 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
1907 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
1908 "Make current window ARG lines bigger.\n\
1909 From program, optional second arg non-nil means grow sideways ARG columns.")
1911 register Lisp_Object n
, side
;
1913 CHECK_NUMBER (n
, 0);
1914 change_window_height (XINT (n
), !NILP (side
));
1918 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
1919 "Make current window ARG lines smaller.\n\
1920 From program, optional second arg non-nil means shrink sideways ARG columns.")
1922 register Lisp_Object n
, side
;
1924 CHECK_NUMBER (n
, 0);
1925 change_window_height (-XINT (n
), !NILP (side
));
1930 window_height (window
)
1933 register struct window
*p
= XWINDOW (window
);
1934 return XFASTINT (p
->height
);
1938 window_width (window
)
1941 register struct window
*p
= XWINDOW (window
);
1942 return XFASTINT (p
->width
);
1945 #define MINSIZE(w) \
1947 ? window_min_width \
1948 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
1951 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
1953 #define CURSIZE(w) \
1954 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
1956 /* Unlike set_window_height, this function
1957 also changes the heights of the siblings so as to
1958 keep everything consistent. */
1960 change_window_height (delta
, widthflag
)
1964 register Lisp_Object parent
;
1966 register struct window
*p
;
1968 int (*sizefun
) () = widthflag
? window_width
: window_height
;
1969 register int (*setsizefun
) () = (widthflag
1971 : set_window_height
);
1973 check_min_window_sizes ();
1975 window
= selected_window
;
1978 p
= XWINDOW (window
);
1983 error ("No other window to side of this one");
1986 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
1987 : !NILP (XWINDOW (parent
)->vchild
))
1992 sizep
= &CURSIZE (window
);
1994 if (*sizep
+ delta
< MINSIZE (window
))
1996 Fdelete_window (window
);
2001 register int maxdelta
;
2003 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2004 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2005 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2006 /* This is a frame with only one window, a minibuffer-only
2007 or a minibufferless frame. */
2010 if (delta
> maxdelta
)
2011 /* This case traps trying to make the minibuffer
2012 the full frame, or make the only window aside from the
2013 minibuffer the full frame. */
2020 if (!NILP (p
->next
) &&
2021 (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2023 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2024 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2025 CURBEG (p
->next
) += delta
;
2026 /* This does not change size of p->next,
2027 but it propagates the new top edge to its children */
2028 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2030 else if (!NILP (p
->prev
) &&
2031 (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2033 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2034 CURBEG (window
) -= delta
;
2035 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2039 register int delta1
;
2040 register int opht
= (*sizefun
) (parent
);
2042 /* If trying to grow this window to or beyond size of the parent,
2043 make delta1 so big that, on shrinking back down,
2044 all the siblings end up with less than one line and are deleted. */
2045 if (opht
<= *sizep
+ delta
)
2046 delta1
= opht
* opht
* 2;
2047 /* Otherwise, make delta1 just right so that if we add delta1
2048 lines to this window and to the parent, and then shrink
2049 the parent back to its original size, the new proportional
2050 size of this window will increase by delta. */
2052 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2054 /* Add delta1 lines or columns to this window, and to the parent,
2055 keeping things consistent while not affecting siblings. */
2056 CURSIZE (parent
) = opht
+ delta1
;
2057 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2059 /* Squeeze out delta1 lines or columns from our parent,
2060 shriking this window and siblings proportionately.
2061 This brings parent back to correct size.
2062 Delta1 was calculated so this makes this window the desired size,
2063 taking it all out of the siblings. */
2064 (*setsizefun
) (parent
, opht
, 0);
2067 XFASTINT (p
->last_modified
) = 0;
2074 /* Return number of lines of text (not counting mode line) in W. */
2077 window_internal_height (w
)
2080 int ht
= XFASTINT (w
->height
);
2082 if (MINI_WINDOW_P (w
))
2085 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2086 || !NILP (w
->next
) || !NILP (w
->prev
)
2087 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2094 /* Return the number of columns in W.
2095 Don't count columns occupied by scroll bars or the vertical bar
2096 separating W from the sibling to its right. */
2098 window_internal_width (w
)
2101 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2102 int left
= XINT (w
->left
);
2103 int width
= XINT (w
->width
);
2105 /* If this window is flush against the right edge of the frame, its
2106 internal width is its full width. */
2107 if (left
+ width
>= FRAME_WIDTH (f
))
2110 /* If we are not flush right, then our rightmost columns are
2111 occupied by some sort of separator. */
2113 /* Scroll bars occupy a few columns. */
2114 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2115 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2117 /* The column of `|' characters separating side-by-side windows
2118 occupies one column only. */
2123 /* Scroll contents of window WINDOW up N lines. */
2126 window_scroll (window
, n
, noerror
)
2131 register struct window
*w
= XWINDOW (window
);
2132 register int opoint
= point
;
2134 register int ht
= window_internal_height (w
);
2135 register Lisp_Object tem
;
2137 Lisp_Object bolp
, nmoved
;
2139 XFASTINT (tem
) = point
;
2140 tem
= Fpos_visible_in_window_p (tem
, window
);
2144 Fvertical_motion (make_number (- ht
/ 2));
2145 XFASTINT (tem
) = point
;
2146 Fset_marker (w
->start
, tem
, w
->buffer
);
2147 w
->force_start
= Qt
;
2150 SET_PT (marker_position (w
->start
));
2151 lose
= n
< 0 && point
== BEGV
;
2152 Fvertical_motion (make_number (n
));
2162 Fsignal (Qbeginning_of_buffer
, Qnil
);
2167 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2168 w
->start_at_line_beg
= bolp
;
2169 w
->update_mode_line
= Qt
;
2170 XFASTINT (w
->last_modified
) = 0;
2176 tem
= Fvertical_motion (make_number (ht
));
2177 if (point
> opoint
|| XFASTINT (tem
) < ht
)
2180 Fvertical_motion (make_number (-1));
2188 Fsignal (Qend_of_buffer
, Qnil
);
2192 /* This is the guts of Fscroll_up and Fscroll_down. */
2195 scroll_command (n
, direction
)
2196 register Lisp_Object n
;
2199 register int defalt
;
2200 int count
= specpdl_ptr
- specpdl
;
2202 /* If selected window's buffer isn't current, make it current for the moment.
2203 But don't screw up if window_scroll gets an error. */
2204 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2206 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2207 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2210 defalt
= (window_internal_height (XWINDOW (selected_window
))
2211 - next_screen_context_lines
);
2212 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2215 window_scroll (selected_window
, defalt
, 0);
2216 else if (EQ (n
, Qminus
))
2217 window_scroll (selected_window
, - defalt
, 0);
2220 n
= Fprefix_numeric_value (n
);
2221 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2224 unbind_to (count
, Qnil
);
2227 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2228 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2229 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2230 When calling from a program, supply a number as argument or nil.")
2234 scroll_command (n
, 1);
2238 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2239 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2240 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2241 When calling from a program, supply a number as argument or nil.")
2245 scroll_command (n
, -1);
2249 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2250 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2251 The next window is the one below the current one; or the one at the top\n\
2252 if the current one is at the bottom.\n\
2253 When calling from a program, supply a number as argument or nil.\n\
2255 If in the minibuffer, `minibuf-scroll-window' if non-nil\n\
2256 specifies the window to scroll.\n\
2257 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2258 showing that buffer, popping the buffer up if necessary.")
2260 register Lisp_Object n
;
2262 register Lisp_Object window
;
2264 register struct window
*w
;
2265 register int count
= specpdl_ptr
- specpdl
;
2267 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2268 && !NILP (Vminibuf_scroll_window
))
2269 window
= Vminibuf_scroll_window
;
2270 /* If buffer is specified, scroll that buffer. */
2271 else if (!NILP (Vother_window_scroll_buffer
))
2273 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2275 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2279 /* Nothing specified; look for a neighboring window on the same
2281 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2283 if (EQ (window
, selected_window
))
2284 /* That didn't get us anywhere; look for a window on another
2287 window
= Fnext_window (window
, Qnil
, Qt
);
2288 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2289 && ! EQ (window
, selected_window
));
2292 CHECK_LIVE_WINDOW (window
, 0);
2294 if (EQ (window
, selected_window
))
2295 error ("There is no other window");
2297 w
= XWINDOW (window
);
2298 ht
= window_internal_height (w
);
2300 /* Don't screw up if window_scroll gets an error. */
2301 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2303 Fset_buffer (w
->buffer
);
2304 SET_PT (marker_position (w
->pointm
));
2307 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2308 else if (EQ (n
, Qminus
))
2309 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2312 if (XTYPE (n
) == Lisp_Cons
)
2314 CHECK_NUMBER (n
, 0);
2315 window_scroll (window
, XINT (n
), 1);
2318 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
2319 unbind_to (count
, Qnil
);
2324 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2325 "Scroll selected window display ARG columns left.\n\
2326 Default for ARG is window width minus 2.")
2328 register Lisp_Object arg
;
2332 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2334 arg
= Fprefix_numeric_value (arg
);
2337 Fset_window_hscroll (selected_window
,
2338 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2342 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2343 "Scroll selected window display ARG columns right.\n\
2344 Default for ARG is window width minus 2.")
2346 register Lisp_Object arg
;
2349 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2351 arg
= Fprefix_numeric_value (arg
);
2354 Fset_window_hscroll (selected_window
,
2355 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2359 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2360 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2361 The desired position of point is always relative to the current window.\n\
2362 Just C-u as prefix means put point in the center of the window.\n\
2363 No arg (i.e., it is nil) erases the entire frame and then\n\
2364 redraws with point in the center of the current window.")
2366 register Lisp_Object n
;
2368 register struct window
*w
= XWINDOW (selected_window
);
2369 register int ht
= window_internal_height (w
);
2370 register int opoint
= point
;
2374 extern int frame_garbaged
;
2376 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2377 XFASTINT (n
) = ht
/ 2;
2379 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2381 XFASTINT (n
) = ht
/ 2;
2385 n
= Fprefix_numeric_value (n
);
2386 CHECK_NUMBER (n
, 0);
2390 XSETINT (n
, XINT (n
) + ht
);
2392 XSETINT (n
, - XINT (n
));
2394 Fvertical_motion (n
);
2395 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2396 w
->start_at_line_beg
= Fbolp ();
2399 w
->force_start
= Qt
;
2404 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2406 "Position point relative to window.\n\
2407 With no argument, position text at center of window.\n\
2408 An argument specifies frame line; zero means top of window,\n\
2409 negative means relative to bottom of window.")
2411 register Lisp_Object arg
;
2413 register struct window
*w
= XWINDOW (selected_window
);
2414 register int height
= window_internal_height (w
);
2418 XFASTINT (arg
) = height
/ 2;
2421 arg
= Fprefix_numeric_value (arg
);
2423 XSETINT (arg
, XINT (arg
) + height
);
2426 start
= marker_position (w
->start
);
2427 if (start
< BEGV
|| start
> ZV
)
2429 Fvertical_motion (make_number (- height
/ 2));
2430 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2431 w
->start_at_line_beg
= Fbolp ();
2432 w
->force_start
= Qt
;
2437 return Fvertical_motion (arg
);
2440 struct save_window_data
2442 int size_from_Lisp_Vector_struct
;
2443 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2444 Lisp_Object frame_width
, frame_height
;
2445 Lisp_Object selected_frame
;
2446 Lisp_Object current_window
;
2447 Lisp_Object current_buffer
;
2448 Lisp_Object minibuf_scroll_window
;
2449 Lisp_Object root_window
;
2450 Lisp_Object focus_frame
;
2451 /* A vector, interpreted as a struct saved_window */
2452 Lisp_Object saved_windows
;
2455 /* Arg to Fmake_vector */
2456 #define SAVE_WINDOW_DATA_SIZE \
2457 ((sizeof (struct save_window_data) \
2458 - (sizeof (struct Lisp_Vector) \
2459 /* Don't count the contents member of the struct Lisp_Vector */ \
2460 - sizeof (Lisp_Object))) \
2461 / sizeof (Lisp_Object))
2463 /* This is saved as a Lisp_Vector */
2466 /* these first two must agree with struct Lisp_Vector in lisp.h */
2467 int size_from_Lisp_Vector_struct
;
2468 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2471 Lisp_Object buffer
, start
, pointm
, mark
;
2472 Lisp_Object left
, top
, width
, height
, hscroll
;
2473 Lisp_Object parent
, prev
;
2474 Lisp_Object start_at_line_beg
;
2475 Lisp_Object display_table
;
2477 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2479 #define SAVED_WINDOW_N(swv,n) \
2480 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2482 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2483 "T if OBJECT is a window-configration object.")
2487 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2493 DEFUN ("set-window-configuration", Fset_window_configuration
,
2494 Sset_window_configuration
, 1, 1, 0,
2495 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2496 CONFIGURATION must be a value previously returned\n\
2497 by `current-window-configuration' (which see).")
2499 Lisp_Object configuration
;
2501 register struct save_window_data
*data
;
2502 struct Lisp_Vector
*saved_windows
;
2503 Lisp_Object new_current_buffer
;
2507 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2509 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2513 data
= (struct save_window_data
*) XVECTOR (configuration
);
2514 saved_windows
= XVECTOR (data
->saved_windows
);
2516 new_current_buffer
= data
->current_buffer
;
2517 if (NILP (XBUFFER (new_current_buffer
)->name
))
2518 new_current_buffer
= Qnil
;
2520 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2523 /* If f is a dead frame, don't bother rebuilding its window tree.
2524 However, there is other stuff we should still try to do below. */
2525 if (FRAME_LIVE_P (f
))
2527 register struct window
*w
;
2528 register struct saved_window
*p
;
2531 /* If the frame has been resized since this window configuration was
2532 made, we change the frame to the size specified in the
2533 configuration, restore the configuration, and then resize it
2534 back. We keep track of the prevailing height in these variables. */
2535 int previous_frame_height
= FRAME_HEIGHT (f
);
2536 int previous_frame_width
= FRAME_WIDTH (f
);
2538 if (XFASTINT (data
->frame_height
) != previous_frame_height
2539 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2540 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2542 windows_or_buffers_changed
++;
2545 Mark all windows now on frame as "deleted".
2546 Restoring the new configuration "undeletes" any that are in it.
2548 Save their current buffers in their height fields, since we may
2549 need it later, if a buffer saved in the configuration is now
2551 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2553 for (k
= 0; k
< saved_windows
->size
; k
++)
2555 p
= SAVED_WINDOW_N (saved_windows
, k
);
2556 w
= XWINDOW (p
->window
);
2559 if (!NILP (p
->parent
))
2560 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2561 XFASTINT (p
->parent
))->window
;
2565 if (!NILP (p
->prev
))
2567 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2568 XFASTINT (p
->prev
))->window
;
2569 XWINDOW (w
->prev
)->next
= p
->window
;
2574 if (!NILP (w
->parent
))
2576 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2578 XWINDOW (w
->parent
)->vchild
= p
->window
;
2579 XWINDOW (w
->parent
)->hchild
= Qnil
;
2583 XWINDOW (w
->parent
)->hchild
= p
->window
;
2584 XWINDOW (w
->parent
)->vchild
= Qnil
;
2589 /* If we squirreled away the buffer in the window's height,
2591 if (XTYPE (w
->height
) == Lisp_Buffer
)
2592 w
->buffer
= w
->height
;
2595 w
->width
= p
->width
;
2596 w
->height
= p
->height
;
2597 w
->hscroll
= p
->hscroll
;
2598 w
->display_table
= p
->display_table
;
2599 XFASTINT (w
->last_modified
) = 0;
2601 /* Reinstall the saved buffer and pointers into it. */
2602 if (NILP (p
->buffer
))
2603 w
->buffer
= p
->buffer
;
2606 if (!NILP (XBUFFER (p
->buffer
)->name
))
2607 /* If saved buffer is alive, install it. */
2609 w
->buffer
= p
->buffer
;
2610 w
->start_at_line_beg
= p
->start_at_line_beg
;
2611 set_marker_restricted (w
->start
,
2612 Fmarker_position (p
->start
),
2614 set_marker_restricted (w
->pointm
,
2615 Fmarker_position (p
->pointm
),
2617 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2618 Fmarker_position (p
->mark
), w
->buffer
);
2620 /* As documented in Fcurrent_window_configuration, don't
2621 save the location of point in the buffer which was current
2622 when the window configuration was recorded. */
2623 if (!EQ (p
->buffer
, new_current_buffer
) &&
2624 XBUFFER (p
->buffer
) == current_buffer
)
2625 Fgoto_char (w
->pointm
);
2627 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2628 /* Else unless window has a live buffer, get one. */
2630 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2631 /* This will set the markers to beginning of visible
2633 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2634 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2635 w
->start_at_line_beg
= Qt
;
2638 /* Keeping window's old buffer; make sure the markers
2641 /* Set window markers at start of visible range. */
2642 if (XMARKER (w
->start
)->buffer
== 0)
2643 set_marker_restricted (w
->start
, make_number (0),
2645 if (XMARKER (w
->pointm
)->buffer
== 0)
2646 set_marker_restricted (w
->pointm
,
2648 (BUF_PT (XBUFFER (w
->buffer
)))),
2650 w
->start_at_line_beg
= Qt
;
2655 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2656 Fselect_window (data
->current_window
);
2659 if (NILP (data
->focus_frame
)
2660 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2661 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2662 Fredirect_frame_focus (frame
, data
->focus_frame
);
2665 #if 0 /* I don't understand why this is needed, and it causes problems
2666 when the frame's old selected window has been deleted. */
2668 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2669 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2673 /* Set the screen height to the value it had before this function. */
2674 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2675 || previous_frame_width
!= FRAME_WIDTH (f
))
2676 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2681 /* Fselect_window will have made f the selected frame, so we
2682 reselect the proper frame here. Fhandle_switch_frame will change the
2683 selected window too, but that doesn't make the call to
2684 Fselect_window above totally superfluous; it still sets f's
2686 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2687 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2690 if (!NILP (new_current_buffer
))
2691 Fset_buffer (new_current_buffer
);
2693 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2697 /* Mark all windows now on frame as deleted
2698 by setting their buffers to nil. */
2701 delete_all_subwindows (w
)
2702 register struct window
*w
;
2704 if (!NILP (w
->next
))
2705 delete_all_subwindows (XWINDOW (w
->next
));
2706 if (!NILP (w
->vchild
))
2707 delete_all_subwindows (XWINDOW (w
->vchild
));
2708 if (!NILP (w
->hchild
))
2709 delete_all_subwindows (XWINDOW (w
->hchild
));
2711 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2713 /* We set all three of these fields to nil, to make sure that we can
2714 distinguish this dead window from any live window. Live leaf
2715 windows will have buffer set, and combination windows will have
2716 vchild or hchild set. */
2723 count_windows (window
)
2724 register struct window
*window
;
2726 register int count
= 1;
2727 if (!NILP (window
->next
))
2728 count
+= count_windows (XWINDOW (window
->next
));
2729 if (!NILP (window
->vchild
))
2730 count
+= count_windows (XWINDOW (window
->vchild
));
2731 if (!NILP (window
->hchild
))
2732 count
+= count_windows (XWINDOW (window
->hchild
));
2737 save_window_save (window
, vector
, i
)
2739 struct Lisp_Vector
*vector
;
2742 register struct saved_window
*p
;
2743 register struct window
*w
;
2744 register Lisp_Object tem
;
2746 for (;!NILP (window
); window
= w
->next
)
2748 p
= SAVED_WINDOW_N (vector
, i
);
2749 w
= XWINDOW (window
);
2751 XFASTINT (w
->temslot
) = i
++;
2753 p
->buffer
= w
->buffer
;
2756 p
->width
= w
->width
;
2757 p
->height
= w
->height
;
2758 p
->hscroll
= w
->hscroll
;
2759 p
->display_table
= w
->display_table
;
2760 if (!NILP (w
->buffer
))
2762 /* Save w's value of point in the window configuration.
2763 If w is the selected window, then get the value of point
2764 from the buffer; pointm is garbage in the selected window. */
2765 if (EQ (window
, selected_window
))
2767 p
->pointm
= Fmake_marker ();
2768 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2772 p
->pointm
= Fcopy_marker (w
->pointm
);
2774 p
->start
= Fcopy_marker (w
->start
);
2775 p
->start_at_line_beg
= w
->start_at_line_beg
;
2777 tem
= XBUFFER (w
->buffer
)->mark
;
2778 p
->mark
= Fcopy_marker (tem
);
2785 p
->start_at_line_beg
= Qnil
;
2788 if (NILP (w
->parent
))
2791 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2796 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2798 if (!NILP (w
->vchild
))
2799 i
= save_window_save (w
->vchild
, vector
, i
);
2800 if (!NILP (w
->hchild
))
2801 i
= save_window_save (w
->hchild
, vector
, i
);
2807 DEFUN ("current-window-configuration",
2808 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2809 "Return an object representing the current window configuration of FRAME.\n\
2810 If FRAME is nil or omitted, use the selected frame.\n\
2811 This describes the number of windows, their sizes and current buffers,\n\
2812 and for each displayed buffer, where display starts, and the positions of\n\
2813 point and mark. An exception is made for point in the current buffer:\n\
2814 its value is -not- saved.\n\
2815 This also records the currently selected frame, and FRAME's focus\n\
2816 redirection (see `redirect-frame-focus').")
2820 register Lisp_Object tem
;
2821 register int n_windows
;
2822 register struct save_window_data
*data
;
2830 CHECK_LIVE_FRAME (frame
, 0);
2834 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2835 data
= (struct save_window_data
*)
2836 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2838 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2839 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2841 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2843 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2844 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2845 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2846 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2847 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2848 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2849 data
->saved_windows
= tem
;
2850 for (i
= 0; i
< n_windows
; i
++)
2851 XVECTOR (tem
)->contents
[i
]
2852 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2853 save_window_save (FRAME_ROOT_WINDOW (f
),
2855 XSET (tem
, Lisp_Window_Configuration
, data
);
2859 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2861 "Execute body, preserving window sizes and contents.\n\
2862 Restores which buffer appears in which window, where display starts,\n\
2863 as well as the current buffer.\n\
2864 Does not restore the value of point in current buffer.")
2868 register Lisp_Object val
;
2869 register int count
= specpdl_ptr
- specpdl
;
2871 record_unwind_protect (Fset_window_configuration
,
2872 Fcurrent_window_configuration (Qnil
));
2873 val
= Fprogn (args
);
2874 return unbind_to (count
, val
);
2880 selected_frame
= make_terminal_frame ();
2881 minibuf_window
= selected_frame
->minibuffer_window
;
2882 selected_window
= selected_frame
->selected_window
;
2883 last_nonminibuf_frame
= selected_frame
;
2884 #else /* not MULTI_FRAME */
2885 extern Lisp_Object
get_minibuffer ();
2887 minibuf_window
= make_window ();
2888 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
2890 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
2891 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
2892 XWINDOW (minibuf_window
)->mini_p
= Qt
;
2894 /* These values 9 and 10 are arbitrary,
2895 just so that there is "something there."
2896 Correct values are put in in init_xdisp */
2898 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
2899 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
2901 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
2902 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
2903 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
2905 /* Prevent error in Fset_window_buffer. */
2906 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
2907 XWINDOW (minibuf_window
)->buffer
= Qt
;
2909 /* Now set them up for real. */
2910 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
2911 Fcurrent_buffer ());
2912 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
2914 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
2915 /* Make sure this window seems more recently used than
2916 a newly-created, never-selected window. Increment
2917 window_select_count so the first selection ever will get
2918 something newer than this. */
2919 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
2920 #endif /* not MULTI_FRAME */
2925 Qwindowp
= intern ("windowp");
2926 staticpro (&Qwindowp
);
2928 Qwindow_live_p
= intern ("window-live-p");
2929 staticpro (&Qwindow_live_p
);
2932 /* Make sure all windows get marked */
2933 staticpro (&minibuf_window
);
2936 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
2937 "Non-nil means call as function to display a help buffer.\n\
2938 Used by `with-output-to-temp-buffer'.");
2939 Vtemp_buffer_show_function
= Qnil
;
2941 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
2942 "If non-nil, function to call to handle `display-buffer'.\n\
2943 It will receive two args, the buffer and a flag which if non-nil means\n\
2944 that the currently selected window is not acceptable.\n\
2945 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
2946 work using this function.");
2947 Vdisplay_buffer_function
= Qnil
;
2949 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
2950 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
2951 Vminibuf_scroll_window
= Qnil
;
2953 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
2954 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
2955 Vother_window_scroll_buffer
= Qnil
;
2957 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
2958 "*Non-nil means `display-buffer' should make a separate frame.");
2961 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
2962 "*If non-nil, function to call to handle automatic new frame creation.\n\
2963 It is called with no arguments and should return a newly created frame.\n\
2965 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
2966 where `pop-up-frame-alist' would hold the default frame parameters.");
2967 Vpop_up_frame_function
= Qnil
;
2969 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
2970 "*Non-nil means display-buffer should make new windows.");
2973 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
2974 "*Number of lines of continuity when scrolling by screenfuls.");
2975 next_screen_context_lines
= 2;
2977 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
2978 "*display-buffer would prefer to split the largest window if this large.\n\
2979 If there is only one window, it is split regardless of this value.");
2980 split_height_threshold
= 500;
2982 DEFVAR_INT ("window-min-height", &window_min_height
,
2983 "*Delete any window less than this tall (including its mode line).");
2984 window_min_height
= 4;
2986 DEFVAR_INT ("window-min-width", &window_min_width
,
2987 "*Delete any window less than this wide.");
2988 window_min_width
= 10;
2990 defsubr (&Sselected_window
);
2991 defsubr (&Sminibuffer_window
);
2992 defsubr (&Swindow_minibuffer_p
);
2993 defsubr (&Swindowp
);
2994 defsubr (&Swindow_live_p
);
2995 defsubr (&Spos_visible_in_window_p
);
2996 defsubr (&Swindow_buffer
);
2997 defsubr (&Swindow_height
);
2998 defsubr (&Swindow_width
);
2999 defsubr (&Swindow_hscroll
);
3000 defsubr (&Sset_window_hscroll
);
3001 defsubr (&Swindow_edges
);
3002 defsubr (&Scoordinates_in_window_p
);
3003 defsubr (&Swindow_at
);
3004 defsubr (&Swindow_point
);
3005 defsubr (&Swindow_start
);
3006 defsubr (&Swindow_end
);
3007 defsubr (&Sset_window_point
);
3008 defsubr (&Sset_window_start
);
3009 defsubr (&Swindow_dedicated_p
);
3010 defsubr (&Sset_window_dedicated_p
);
3011 defsubr (&Swindow_display_table
);
3012 defsubr (&Sset_window_display_table
);
3013 defsubr (&Snext_window
);
3014 defsubr (&Sprevious_window
);
3015 defsubr (&Sother_window
);
3016 defsubr (&Sget_lru_window
);
3017 defsubr (&Sget_largest_window
);
3018 defsubr (&Sget_buffer_window
);
3019 defsubr (&Sdelete_other_windows
);
3020 defsubr (&Sdelete_windows_on
);
3021 defsubr (&Sreplace_buffer_in_windows
);
3022 defsubr (&Sdelete_window
);
3023 defsubr (&Sset_window_buffer
);
3024 defsubr (&Sselect_window
);
3025 defsubr (&Sdisplay_buffer
);
3026 defsubr (&Ssplit_window
);
3027 defsubr (&Senlarge_window
);
3028 defsubr (&Sshrink_window
);
3029 defsubr (&Sscroll_up
);
3030 defsubr (&Sscroll_down
);
3031 defsubr (&Sscroll_left
);
3032 defsubr (&Sscroll_right
);
3033 defsubr (&Sscroll_other_window
);
3034 defsubr (&Srecenter
);
3035 defsubr (&Smove_to_window_line
);
3036 defsubr (&Swindow_configuration_p
);
3037 defsubr (&Sset_window_configuration
);
3038 defsubr (&Scurrent_window_configuration
);
3039 defsubr (&Ssave_window_excursion
);
3044 initial_define_key (control_x_map
, '1', "delete-other-windows");
3045 initial_define_key (control_x_map
, '2', "split-window");
3046 initial_define_key (control_x_map
, '0', "delete-window");
3047 initial_define_key (control_x_map
, 'o', "other-window");
3048 initial_define_key (control_x_map
, '^', "enlarge-window");
3049 initial_define_key (control_x_map
, '<', "scroll-left");
3050 initial_define_key (control_x_map
, '>', "scroll-right");
3052 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3053 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3054 initial_define_key (meta_map
, 'v', "scroll-down");
3056 initial_define_key (global_map
, Ctl('L'), "recenter");
3057 initial_define_key (meta_map
, 'r', "move-to-window-line");