1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985,86,87,93,94,95,96,97,1998,2000
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
33 #include "dispextern.h"
34 #include "blockinput.h"
35 #include "intervals.h"
39 #endif /* HAVE_X_WINDOWS */
51 #define max(a, b) ((a) < (b) ? (b) : (a))
55 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
56 Lisp_Object Qwindow_size_fixed
, Qleft_bitmap_area
, Qright_bitmap_area
;
57 extern Lisp_Object Qheight
, Qwidth
;
59 static struct window
*decode_window
P_ ((Lisp_Object
));
60 static Lisp_Object select_window_1
P_ ((Lisp_Object
, int));
61 static int count_windows
P_ ((struct window
*));
62 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
63 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
64 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
65 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
66 static int window_min_size_1
P_ ((struct window
*, int));
67 static int window_min_size
P_ ((struct window
*, int, int, int *));
68 static void size_window
P_ ((Lisp_Object
, int, int, int));
69 static int freeze_window_start
P_ ((struct window
*, void *));
70 static int window_fixed_size_p
P_ ((struct window
*, int, int));
71 static void enlarge_window
P_ ((Lisp_Object
, int, int));
72 static Lisp_Object window_list
P_ ((void));
73 static int add_window_to_list
P_ ((struct window
*, void *));
74 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
80 static int foreach_window_1
P_ ((struct window
*,
81 int (* fn
) (struct window
*, void *),
83 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
85 /* This is the window in which the terminal's cursor should
86 be left when nothing is being done with it. This must
87 always be a leaf window, and its buffer is selected by
88 the top level editing loop at the end of each command.
90 This value is always the same as
91 FRAME_SELECTED_WINDOW (selected_frame). */
93 Lisp_Object selected_window
;
95 /* A list of all windows for use by next_window and Fwindow_list.
96 Functions creating or deleting windows should invalidate this cache
97 by setting it to nil. */
99 Lisp_Object Vwindow_list
;
101 /* The mini-buffer window of the selected frame.
102 Note that you cannot test for mini-bufferness of an arbitrary window
103 by comparing against this; but you can test for mini-bufferness of
104 the selected window. */
106 Lisp_Object minibuf_window
;
108 /* Non-nil means it is the window for C-M-v to scroll
109 when the mini-buffer is selected. */
111 Lisp_Object Vminibuf_scroll_window
;
113 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
115 Lisp_Object Vother_window_scroll_buffer
;
117 /* Non-nil means it's function to call to display temp buffers. */
119 Lisp_Object Vtemp_buffer_show_function
;
121 /* If a window gets smaller than either of these, it is removed. */
123 int window_min_height
;
124 int window_min_width
;
126 /* Nonzero implies Fdisplay_buffer should create windows. */
130 /* Nonzero implies make new frames for Fdisplay_buffer. */
134 /* Nonzero means reuse existing frames for displaying buffers. */
136 int display_buffer_reuse_frames
;
138 /* Non-nil means use this function instead of default */
140 Lisp_Object Vpop_up_frame_function
;
142 /* Function to call to handle Fdisplay_buffer. */
144 Lisp_Object Vdisplay_buffer_function
;
146 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
148 Lisp_Object Veven_window_heights
;
150 /* List of buffer *names* for buffers that should have their own frames. */
152 Lisp_Object Vspecial_display_buffer_names
;
154 /* List of regexps for buffer names that should have their own frames. */
156 Lisp_Object Vspecial_display_regexps
;
158 /* Function to pop up a special frame. */
160 Lisp_Object Vspecial_display_function
;
162 /* List of buffer *names* for buffers to appear in selected window. */
164 Lisp_Object Vsame_window_buffer_names
;
166 /* List of regexps for buffer names to appear in selected window. */
168 Lisp_Object Vsame_window_regexps
;
170 /* Hook run at end of temp_output_buffer_show. */
172 Lisp_Object Qtemp_buffer_show_hook
;
174 /* Fdisplay_buffer always splits the largest window
175 if that window is more than this high. */
177 int split_height_threshold
;
179 /* Number of lines of continuity in scrolling by screenfuls. */
181 int next_screen_context_lines
;
183 /* Incremented for each window created. */
185 static int sequence_number
;
187 /* Nonzero after init_window_once has finished. */
189 static int window_initialized
;
191 /* Hook to run when window config changes. */
193 Lisp_Object Qwindow_configuration_change_hook
;
194 Lisp_Object Vwindow_configuration_change_hook
;
196 /* Nonzero means scroll commands try to put point
197 at the same screen height as previously. */
199 Lisp_Object Vscroll_preserve_screen_position
;
201 #if 0 /* This isn't used anywhere. */
202 /* Nonzero means we can split a frame even if it is "unsplittable". */
203 static int inhibit_frame_unsplittable
;
206 #define min(a, b) ((a) < (b) ? (a) : (b))
208 extern int scroll_margin
;
210 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
212 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
213 "Returns t if OBJECT is a window.")
217 return WINDOWP (object
) ? Qt
: Qnil
;
220 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
221 "Returns t if OBJECT is a window which is currently visible.")
225 return (WINDOWP (object
) && ! NILP (XWINDOW (object
)->buffer
) ? Qt
: Qnil
);
232 register struct window
*p
;
233 register struct Lisp_Vector
*vec
;
236 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct window
));
237 for (i
= 0; i
< VECSIZE (struct window
); i
++)
238 vec
->contents
[i
] = Qnil
;
239 vec
->size
= VECSIZE (struct window
);
240 p
= (struct window
*) vec
;
241 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
242 XSETFASTINT (p
->left
, 0);
243 XSETFASTINT (p
->top
, 0);
244 XSETFASTINT (p
->height
, 0);
245 XSETFASTINT (p
->width
, 0);
246 XSETFASTINT (p
->hscroll
, 0);
247 p
->orig_top
= p
->orig_height
= Qnil
;
248 p
->start
= Fmake_marker ();
249 p
->pointm
= Fmake_marker ();
250 XSETFASTINT (p
->use_time
, 0);
252 p
->display_table
= Qnil
;
254 p
->pseudo_window_p
= 0;
255 bzero (&p
->cursor
, sizeof (p
->cursor
));
256 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
257 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
258 p
->desired_matrix
= p
->current_matrix
= 0;
259 p
->phys_cursor_type
= -1;
260 p
->must_be_updated_p
= 0;
261 XSETFASTINT (p
->window_end_vpos
, 0);
262 XSETFASTINT (p
->window_end_pos
, 0);
263 p
->window_end_valid
= Qnil
;
266 XSETFASTINT (p
->last_point
, 0);
267 p
->frozen_window_start_p
= 0;
273 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
274 "Return the window that the cursor now appears in and commands apply to.")
277 return selected_window
;
280 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
281 "Return the window used now for minibuffers.\n\
282 If the optional argument FRAME is specified, return the minibuffer window\n\
283 used by that frame.")
288 frame
= selected_frame
;
289 CHECK_LIVE_FRAME (frame
, 0);
290 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
293 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
294 "Returns non-nil if WINDOW is a minibuffer window.")
298 struct window
*w
= decode_window (window
);
299 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
303 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
304 Spos_visible_in_window_p
, 0, 3, 0,
305 "Return t if position POS is currently on the frame in WINDOW.\n\
306 Return nil if that position is scrolled vertically out of view.\n\
307 If a character is only partially visible, nil is returned, unless the\n\
308 optional argument PARTIALLY is non-nil.\n\
309 POS defaults to point in WINDOW; WINDOW defaults to the selected window.")
310 (pos
, window
, partially
)
311 Lisp_Object pos
, window
, partially
;
313 register struct window
*w
;
315 register struct buffer
*buf
;
317 Lisp_Object in_window
;
320 w
= decode_window (window
);
321 buf
= XBUFFER (w
->buffer
);
322 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
326 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
329 else if (w
== XWINDOW (selected_window
))
332 posint
= XMARKER (w
->pointm
)->charpos
;
334 /* If position is above window start, it's not visible. */
335 if (posint
< CHARPOS (top
))
337 else if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
)
338 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (buf
)
339 && posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
))
341 /* If frame is up-to-date, and POSINT is < window end pos, use
342 that info. This doesn't work for POSINT == end pos, because
343 the window end pos is actually the position _after_ the last
344 char in the window. */
345 if (NILP (partially
))
347 pos_visible_p (w
, posint
, &fully_p
, NILP (partially
));
348 in_window
= fully_p
? Qt
: Qnil
;
353 else if (posint
> BUF_ZV (buf
))
355 else if (CHARPOS (top
) < BUF_BEGV (buf
) || CHARPOS (top
) > BUF_ZV (buf
))
356 /* If window start is out of range, do something reasonable. */
360 if (pos_visible_p (w
, posint
, &fully_p
, NILP (partially
)))
361 in_window
= !NILP (partially
) || fully_p
? Qt
: Qnil
;
370 static struct window
*
371 decode_window (window
)
372 register Lisp_Object window
;
375 return XWINDOW (selected_window
);
377 CHECK_LIVE_WINDOW (window
, 0);
378 return XWINDOW (window
);
381 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
382 "Return the buffer that WINDOW is displaying.")
386 return decode_window (window
)->buffer
;
389 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
390 "Return the number of lines in WINDOW (including its mode line).")
394 return decode_window (window
)->height
;
397 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
398 "Return the number of display columns in WINDOW.\n\
399 This is the width that is usable columns available for text in WINDOW.\n\
400 If you want to find out how many columns WINDOW takes up,\n\
401 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
405 return make_number (window_internal_width (decode_window (window
)));
408 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
409 "Return the number of columns by which WINDOW is scrolled from left margin.")
413 return decode_window (window
)->hscroll
;
416 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
417 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
418 NCOL should be zero or positive.")
420 register Lisp_Object window
, ncol
;
422 register struct window
*w
;
424 CHECK_NUMBER (ncol
, 1);
425 if (XINT (ncol
) < 0) XSETFASTINT (ncol
, 0);
426 w
= decode_window (window
);
427 if (XINT (w
->hscroll
) != XINT (ncol
))
428 /* Prevent redisplay shortcuts */
429 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
434 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
435 Swindow_redisplay_end_trigger
, 0, 1, 0,
436 "Return WINDOW's redisplay end trigger value.\n\
437 See `set-window-redisplay-end-trigger' for more information.")
441 return decode_window (window
)->redisplay_end_trigger
;
444 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
445 Sset_window_redisplay_end_trigger
, 2, 2, 0,
446 "Set WINDOW's redisplay end trigger value to VALUE.\n\
447 VALUE should be a buffer position (typically a marker) or nil.\n\
448 If it is a buffer position, then if redisplay in WINDOW reaches a position\n\
449 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called\n\
450 with two arguments: WINDOW, and the end trigger value.\n\
451 Afterwards the end-trigger value is reset to nil.")
453 register Lisp_Object window
, value
;
455 register struct window
*w
;
457 w
= decode_window (window
);
458 w
->redisplay_end_trigger
= value
;
462 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
463 "Return a list of the edge coordinates of WINDOW.\n\
464 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
465 RIGHT is one more than the rightmost column used by WINDOW,\n\
466 and BOTTOM is one more than the bottommost row used by WINDOW\n\
471 register struct window
*w
= decode_window (window
);
473 return Fcons (w
->left
, Fcons (w
->top
,
474 Fcons (make_number (WINDOW_RIGHT_EDGE (w
)),
475 Fcons (make_number (XFASTINT (w
->top
)
476 + XFASTINT (w
->height
)),
480 /* Test if the character at column *X, row *Y is within window W.
481 If it is not, return 0;
482 if it is in the window's text area,
483 set *x and *y to its location relative to the upper left corner
486 if it is on the window's modeline, return 2;
487 if it is on the border between the window and its right sibling,
489 if it is on the window's top line, return 4;
490 if it is in the bitmap area to the left/right of the window,
491 return 5 or 6, and convert *X and *Y to window-relative corrdinates.
493 X and Y are frame relative pixel coordinates. */
496 coordinates_in_window (w
, x
, y
)
497 register struct window
*w
;
500 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
501 int left_x
, right_x
, top_y
, bottom_y
;
502 int flags_area_width
= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
504 /* Let's make this a global enum later, instead of using numbers
506 enum {ON_NOTHING
, ON_TEXT
, ON_MODE_LINE
, ON_VERTICAL_BORDER
,
507 ON_HEADER_LINE
, ON_LEFT_FRINGE
, ON_RIGHT_FRINGE
};
509 /* In what's below, we subtract 1 when computing right_x because we
510 want the rightmost pixel, which is given by left_pixel+width-1. */
511 if (w
->pseudo_window_p
)
514 right_x
= XFASTINT (w
->width
) * CANON_Y_UNIT (f
) - 1;
515 top_y
= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
516 bottom_y
= WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w
);
520 left_x
= (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
)
521 - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
));
522 right_x
= WINDOW_DISPLAY_RIGHT_EDGE_PIXEL_X (w
) - 1;
523 top_y
= (WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
)
524 - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
));
525 bottom_y
= WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w
);
528 /* On the mode line or header line? If it's near the start of
529 the mode or header line of window that's has a horizontal
530 sibling, say it's on the vertical line. That's to be able
531 to resize windows horizontally in case we're using toolkit
534 if (WINDOW_WANTS_MODELINE_P (w
)
536 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
538 if (!WINDOW_RIGHTMOST_P (w
)
539 && (abs (*x
- ((XFASTINT (w
->left
) + XFASTINT (w
->width
))
541 < CANON_X_UNIT (f
) / 2))
542 return ON_VERTICAL_BORDER
;
546 if (WINDOW_WANTS_HEADER_LINE_P (w
)
548 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
550 if (!WINDOW_RIGHTMOST_P (w
)
551 && (abs (*x
- ((XFASTINT (w
->left
) + XFASTINT (w
->width
))
553 < CANON_X_UNIT (f
) / 2))
554 return ON_VERTICAL_BORDER
;
555 return ON_HEADER_LINE
;
558 /* Completely outside anything interesting? */
563 - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
)
565 || *x
> right_x
+ flags_area_width
)
568 if (FRAME_WINDOW_P (f
))
570 if (!w
->pseudo_window_p
571 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
572 && !WINDOW_RIGHTMOST_P (w
)
573 && (abs (*x
- right_x
- flags_area_width
) < CANON_X_UNIT (f
) / 2))
574 return ON_VERTICAL_BORDER
;
576 if (*x
< left_x
|| *x
> right_x
)
578 /* Other lines than the mode line don't include flags areas and
579 scroll bars on the left. */
581 /* Convert X and Y to window-relative pixel coordinates. */
584 return *x
< left_x
? ON_LEFT_FRINGE
: ON_RIGHT_FRINGE
;
589 /* Need to say "*x > right_x" rather than >=, since on character
590 terminals, the vertical line's x coordinate is right_x. */
591 if (*x
< left_x
|| *x
> right_x
)
593 /* Other lines than the mode line don't include flags areas and
594 scroll bars on the left. */
596 /* Convert X and Y to window-relative pixel coordinates. */
599 return *x
< left_x
? ON_LEFT_FRINGE
: ON_RIGHT_FRINGE
;
602 /* Here, too, "*x > right_x" is because of character terminals. */
603 if (!w
->pseudo_window_p
604 && !WINDOW_RIGHTMOST_P (w
)
605 && *x
> right_x
- CANON_X_UNIT (f
))
606 /* On the border on the right side of the window? Assume that
607 this area begins at RIGHT_X minus a canonical char width. */
608 return ON_VERTICAL_BORDER
;
611 /* Convert X and Y to window-relative pixel coordinates. */
617 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
618 Scoordinates_in_window_p
, 2, 2, 0,
619 "Return non-nil if COORDINATES are in WINDOW.\n\
620 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
621 measured in characters from the upper-left corner of the frame.\n\
622 (0 . 0) denotes the character in the upper left corner of the\n\
624 If COORDINATES are in the text portion of WINDOW,\n\
625 the coordinates relative to the window are returned.\n\
626 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
627 If they are in the top mode line of WINDOW, `header-line' is returned.\n\
628 If they are in the bitmap-area to the left of the window,\n\
629 `left-bitmap-area' is returned, if they are in the area on the right of\n\
630 the window, `right-bitmap-area' is returned.\n\
631 If they are on the border between WINDOW and its right sibling,\n\
632 `vertical-line' is returned.")
633 (coordinates
, window
)
634 register Lisp_Object coordinates
, window
;
641 CHECK_LIVE_WINDOW (window
, 0);
642 w
= XWINDOW (window
);
643 f
= XFRAME (w
->frame
);
644 CHECK_CONS (coordinates
, 1);
645 lx
= Fcar (coordinates
);
646 ly
= Fcdr (coordinates
);
647 CHECK_NUMBER_OR_FLOAT (lx
, 1);
648 CHECK_NUMBER_OR_FLOAT (ly
, 1);
649 x
= PIXEL_X_FROM_CANON_X (f
, lx
);
650 y
= PIXEL_Y_FROM_CANON_Y (f
, ly
);
652 switch (coordinates_in_window (w
, &x
, &y
))
654 case 0: /* NOT in window at all. */
657 case 1: /* In text part of window. */
658 /* X and Y are now window relative pixel coordinates.
659 Convert them to canonical char units before returning
661 return Fcons (CANON_X_FROM_PIXEL_X (f
, x
),
662 CANON_Y_FROM_PIXEL_Y (f
, y
));
664 case 2: /* In mode line of window. */
667 case 3: /* On right border of window. */
668 return Qvertical_line
;
674 return Qleft_bitmap_area
;
677 return Qright_bitmap_area
;
685 /* Callback for foreach_window, used in window_from_coordinates.
686 Check if window W contains coordinates specified by USER_DATA which
687 is actually a pointer to a struct check_window_data CW.
689 Check if window W contains coordinates *CW->x and *CW->y. If it
690 does, return W in *CW->window, as Lisp_Object, and return in
691 *CW->part the part of the window under coordinates *X,*Y. Return
692 zero from this function to stop iterating over windows. */
694 struct check_window_data
701 check_window_containing (w
, user_data
)
705 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
708 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
711 *cw
->part
= found
- 1;
712 XSETWINDOW (*cw
->window
, w
);
719 /* Find the window containing frame-relative pixel position X/Y and
720 return it as a Lisp_Object. If X, Y is on the window's modeline,
721 set *PART to 1; if it is on the separating line between the window
722 and its right sibling, set it to 2; otherwise set it to 0. If
723 there is no window under X, Y return nil and leave *PART
724 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
726 This function was previously implemented with a loop cycling over
727 windows with Fnext_window, and starting with the frame's selected
728 window. It turned out that this doesn't work with an
729 implementation of next_window using Vwindow_list, because
730 FRAME_SELECTED_WINDOW (F) is not always contained in the window
731 tree of F when this function is called asynchronously from
732 note_mouse_highlight. The original loop didn't terminate in this
736 window_from_coordinates (f
, x
, y
, part
, tool_bar_p
)
743 struct check_window_data cw
;
746 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
747 foreach_window (f
, check_window_containing
, &cw
);
749 /* If not found above, see if it's in the tool bar window, if a tool
753 && WINDOWP (f
->tool_bar_window
)
754 && XINT (XWINDOW (f
->tool_bar_window
)->height
) > 0
755 && coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
))
758 window
= f
->tool_bar_window
;
764 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
765 "Return window containing coordinates X and Y on FRAME.\n\
766 If omitted, FRAME defaults to the currently selected frame.\n\
767 The top left corner of the frame is considered to be row 0,\n\
770 Lisp_Object x
, y
, frame
;
776 frame
= selected_frame
;
777 CHECK_LIVE_FRAME (frame
, 2);
780 /* Check that arguments are integers or floats. */
781 CHECK_NUMBER_OR_FLOAT (x
, 0);
782 CHECK_NUMBER_OR_FLOAT (y
, 1);
784 return window_from_coordinates (f
,
785 PIXEL_X_FROM_CANON_X (f
, x
),
786 PIXEL_Y_FROM_CANON_Y (f
, y
),
790 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
791 "Return current value of point in WINDOW.\n\
792 For a nonselected window, this is the value point would have\n\
793 if that window were selected.\n\
795 Note that, when WINDOW is the selected window and its buffer\n\
796 is also currently selected, the value returned is the same as (point).\n\
797 It would be more strictly correct to return the `top-level' value\n\
798 of point, outside of any save-excursion forms.\n\
799 But that is hard to define.")
803 register struct window
*w
= decode_window (window
);
805 if (w
== XWINDOW (selected_window
)
806 && current_buffer
== XBUFFER (w
->buffer
))
808 return Fmarker_position (w
->pointm
);
811 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
812 "Return position at which display currently starts in WINDOW.\n\
813 This is updated by redisplay or by calling `set-window-start'.")
817 return Fmarker_position (decode_window (window
)->start
);
820 /* This is text temporarily removed from the doc string below.
822 This function returns nil if the position is not currently known.\n\
823 That happens when redisplay is preempted and doesn't finish.\n\
824 If in that case you want to compute where the end of the window would\n\
825 have been if redisplay had finished, do this:\n\
827 (goto-char (window-start window))\n\
828 (vertical-motion (1- (window-height window)) window)\n\
831 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
832 "Return position at which display currently ends in WINDOW.\n\
833 This is updated by redisplay, when it runs to completion.\n\
834 Simply changing the buffer text or setting `window-start'\n\
835 does not update this value.\n\
836 If UP-TO-DATE is non-nil, compute the up-to-date position\n\
837 if it isn't already recorded.")
839 Lisp_Object window
, update
;
842 struct window
*w
= decode_window (window
);
846 CHECK_BUFFER (buf
, 0);
848 #if 0 /* This change broke some things. We should make it later. */
849 /* If we don't know the end position, return nil.
850 The user can compute it with vertical-motion if he wants to.
851 It would be nicer to do it automatically,
852 but that's so slow that it would probably bother people. */
853 if (NILP (w
->window_end_valid
))
858 && ! (! NILP (w
->window_end_valid
)
859 && XFASTINT (w
->last_modified
) >= MODIFF
))
861 struct text_pos startp
;
864 /* In case W->start is out of the range, use something
865 reasonable. This situation occured when loading a file with
866 `-l' containing a call to `rmail' with subsequent other
867 commands. At the end, W->start happened to be BEG, while
868 rmail had already narrowed the buffer. */
869 if (XMARKER (w
->start
)->charpos
< BEGV
)
870 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
871 else if (XMARKER (w
->start
)->charpos
> ZV
)
872 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
874 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
876 /* Cannot use Fvertical_motion because that function doesn't
877 cope with variable-height lines. */
878 start_display (&it
, w
, startp
);
879 move_it_vertically (&it
, window_box_height (w
));
880 value
= make_number (IT_CHARPOS (it
));
883 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
888 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
889 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
891 Lisp_Object window
, pos
;
893 register struct window
*w
= decode_window (window
);
895 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
896 if (w
== XWINDOW (selected_window
)
897 && XBUFFER (w
->buffer
) == current_buffer
)
900 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
902 /* If displaying hollow box cursors in non-selected windows, we have
903 to make sure that redisplay updates the window to show the new
905 if (cursor_in_non_selected_windows
&& !EQ (window
, selected_window
))
906 ++windows_or_buffers_changed
;
911 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
912 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
913 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
914 from overriding motion of point in order to display at this exact start.")
915 (window
, pos
, noforce
)
916 Lisp_Object window
, pos
, noforce
;
918 register struct window
*w
= decode_window (window
);
920 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
921 set_marker_restricted (w
->start
, pos
, w
->buffer
);
922 /* this is not right, but much easier than doing what is right. */
923 w
->start_at_line_beg
= Qnil
;
926 w
->update_mode_line
= Qt
;
927 XSETFASTINT (w
->last_modified
, 0);
928 XSETFASTINT (w
->last_overlay_modified
, 0);
929 if (!EQ (window
, selected_window
))
930 windows_or_buffers_changed
++;
935 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
937 "Return WINDOW's dedicated object, usually t or nil.\n\
938 See also `set-window-dedicated-p'.")
942 return decode_window (window
)->dedicated
;
945 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
946 Sset_window_dedicated_p
, 2, 2, 0,
947 "Control whether WINDOW is dedicated to the buffer it displays.\n\
948 If it is dedicated, Emacs will not automatically change\n\
949 which buffer appears in it.\n\
950 The second argument is the new value for the dedication flag;\n\
953 Lisp_Object window
, arg
;
955 register struct window
*w
= decode_window (window
);
965 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
967 "Return the display-table that WINDOW is using.")
971 return decode_window (window
)->display_table
;
974 /* Get the display table for use on window W. This is either W's
975 display table or W's buffer's display table. Ignore the specified
976 tables if they are not valid; if no valid table is specified,
979 struct Lisp_Char_Table
*
980 window_display_table (w
)
983 struct Lisp_Char_Table
*dp
= NULL
;
985 if (DISP_TABLE_P (w
->display_table
))
986 dp
= XCHAR_TABLE (w
->display_table
);
987 else if (BUFFERP (w
->buffer
))
989 struct buffer
*b
= XBUFFER (w
->buffer
);
991 if (DISP_TABLE_P (b
->display_table
))
992 dp
= XCHAR_TABLE (b
->display_table
);
993 else if (DISP_TABLE_P (Vstandard_display_table
))
994 dp
= XCHAR_TABLE (Vstandard_display_table
);
1000 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1001 "Set WINDOW's display-table to TABLE.")
1003 register Lisp_Object window
, table
;
1005 register struct window
*w
;
1007 w
= decode_window (window
);
1008 w
->display_table
= table
;
1012 /* Record info on buffer window w is displaying
1013 when it is about to cease to display that buffer. */
1016 register struct window
*w
;
1023 if (b
!= XMARKER (w
->pointm
)->buffer
)
1027 if (w
== XWINDOW (selected_window
)
1028 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1029 /* Do this except when the selected window's buffer
1030 is being removed from some other window. */
1032 /* last_window_start records the start position that this buffer
1033 had in the last window to be disconnected from it.
1034 Now that this statement is unconditional,
1035 it is possible for the buffer to be displayed in the
1036 selected window, while last_window_start reflects another
1037 window which was recently showing the same buffer.
1038 Some people might say that might be a good thing. Let's see. */
1039 b
->last_window_start
= marker_position (w
->start
);
1041 /* Point in the selected window's buffer
1042 is actually stored in that buffer, and the window's pointm isn't used.
1043 So don't clobber point in that buffer. */
1044 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1045 /* This line helps to fix Horsley's testbug.el bug. */
1046 && !(WINDOWP (b
->last_selected_window
)
1047 && w
!= XWINDOW (b
->last_selected_window
)
1048 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1049 temp_set_point_both (b
,
1050 clip_to_bounds (BUF_BEGV (b
),
1051 XMARKER (w
->pointm
)->charpos
,
1053 clip_to_bounds (BUF_BEGV_BYTE (b
),
1054 marker_byte_position (w
->pointm
),
1057 if (WINDOWP (b
->last_selected_window
)
1058 && w
== XWINDOW (b
->last_selected_window
))
1059 b
->last_selected_window
= Qnil
;
1062 /* Put replacement into the window structure in place of old. */
1064 replace_window (old
, replacement
)
1065 Lisp_Object old
, replacement
;
1067 register Lisp_Object tem
;
1068 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1070 /* If OLD is its frame's root_window, then replacement is the new
1071 root_window for that frame. */
1073 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1074 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1078 p
->width
= o
->width
;
1079 p
->height
= o
->height
;
1080 p
->desired_matrix
= p
->current_matrix
= 0;
1082 bzero (&p
->cursor
, sizeof (p
->cursor
));
1083 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1084 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1085 p
->phys_cursor_type
= -1;
1086 p
->must_be_updated_p
= 0;
1087 p
->pseudo_window_p
= 0;
1088 XSETFASTINT (p
->window_end_vpos
, 0);
1089 XSETFASTINT (p
->window_end_pos
, 0);
1090 p
->window_end_valid
= Qnil
;
1091 p
->frozen_window_start_p
= 0;
1092 p
->orig_top
= p
->orig_height
= Qnil
;
1094 p
->next
= tem
= o
->next
;
1096 XWINDOW (tem
)->prev
= replacement
;
1098 p
->prev
= tem
= o
->prev
;
1100 XWINDOW (tem
)->next
= replacement
;
1102 p
->parent
= tem
= o
->parent
;
1105 if (EQ (XWINDOW (tem
)->vchild
, old
))
1106 XWINDOW (tem
)->vchild
= replacement
;
1107 if (EQ (XWINDOW (tem
)->hchild
, old
))
1108 XWINDOW (tem
)->hchild
= replacement
;
1111 /*** Here, if replacement is a vertical combination
1112 and so is its new parent, we should make replacement's
1113 children be children of that parent instead. ***/
1116 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1117 "Remove WINDOW from the display. Default is selected window.")
1119 register Lisp_Object window
;
1121 delete_window (window
);
1123 if (! NILP (Vwindow_configuration_change_hook
)
1124 && ! NILP (Vrun_hooks
))
1125 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1131 delete_window (window
)
1132 register Lisp_Object window
;
1134 register Lisp_Object tem
, parent
, sib
;
1135 register struct window
*p
;
1136 register struct window
*par
;
1139 /* Because this function is called by other C code on non-leaf
1140 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1141 so we can't decode_window here. */
1143 window
= selected_window
;
1145 CHECK_WINDOW (window
, 0);
1146 p
= XWINDOW (window
);
1148 /* It's okay to delete an already-deleted window. */
1149 if (NILP (p
->buffer
)
1151 && NILP (p
->vchild
))
1156 error ("Attempt to delete minibuffer or sole ordinary window");
1157 par
= XWINDOW (parent
);
1159 windows_or_buffers_changed
++;
1160 Vwindow_list
= Qnil
;
1161 frame
= XFRAME (WINDOW_FRAME (p
));
1162 FRAME_WINDOW_SIZES_CHANGED (frame
) = 1;
1164 /* Are we trying to delete any frame's selected window? */
1166 Lisp_Object frame
, pwindow
;
1168 /* See if the frame's selected window is either WINDOW
1169 or any subwindow of it, by finding all that window's parents
1170 and comparing each one with WINDOW. */
1171 frame
= WINDOW_FRAME (XWINDOW (window
));
1172 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
1174 while (!NILP (pwindow
))
1176 if (EQ (window
, pwindow
))
1178 pwindow
= XWINDOW (pwindow
)->parent
;
1181 if (EQ (window
, pwindow
))
1183 Lisp_Object alternative
;
1184 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
1186 /* If we're about to delete the selected window on the
1187 selected frame, then we should use Fselect_window to select
1188 the new window. On the other hand, if we're about to
1189 delete the selected window on any other frame, we shouldn't do
1190 anything but set the frame's selected_window slot. */
1191 if (EQ (window
, selected_window
))
1192 Fselect_window (alternative
);
1194 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
1199 /* tem is null for dummy parent windows
1200 (which have inferiors but not any contents themselves) */
1204 unchain_marker (p
->pointm
);
1205 unchain_marker (p
->start
);
1208 /* Free window glyph matrices. It is sure that they are allocated
1209 again when ADJUST_GLYPHS is called. Block input so that expose
1210 events and other events that access glyph matrices are not
1211 processed while we are changing them. */
1213 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (frame
)));
1217 XWINDOW (tem
)->prev
= p
->prev
;
1221 XWINDOW (tem
)->next
= p
->next
;
1223 if (EQ (window
, par
->hchild
))
1224 par
->hchild
= p
->next
;
1225 if (EQ (window
, par
->vchild
))
1226 par
->vchild
= p
->next
;
1228 /* Find one of our siblings to give our space to. */
1232 /* If p gives its space to its next sibling, that sibling needs
1233 to have its top/left side pulled back to where p's is.
1234 set_window_{height,width} will re-position the sibling's
1237 XWINDOW (sib
)->top
= p
->top
;
1238 XWINDOW (sib
)->left
= p
->left
;
1241 /* Stretch that sibling. */
1242 if (!NILP (par
->vchild
))
1243 set_window_height (sib
,
1244 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
1246 if (!NILP (par
->hchild
))
1247 set_window_width (sib
,
1248 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
1251 /* If parent now has only one child,
1252 put the child into the parent's place. */
1256 if (NILP (XWINDOW (tem
)->next
))
1257 replace_window (parent
, tem
);
1259 /* Since we may be deleting combination windows, we must make sure that
1260 not only p but all its children have been marked as deleted. */
1261 if (! NILP (p
->hchild
))
1262 delete_all_subwindows (XWINDOW (p
->hchild
));
1263 else if (! NILP (p
->vchild
))
1264 delete_all_subwindows (XWINDOW (p
->vchild
));
1266 /* Mark this window as deleted. */
1267 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1269 /* Adjust glyph matrices. */
1270 adjust_glyphs (frame
);
1276 /***********************************************************************
1278 ***********************************************************************/
1280 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1281 pointer. This is a callback function for foreach_window, used in
1282 function window_list. */
1285 add_window_to_list (w
, user_data
)
1289 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1291 XSETWINDOW (window
, w
);
1292 *list
= Fcons (window
, *list
);
1297 /* Return a list of all windows, for use by next_window. If
1298 Vwindow_list is a list, return that list. Otherwise, build a new
1299 list, cache it in Vwindow_list, and return that. */
1304 if (!CONSP (Vwindow_list
))
1308 Vwindow_list
= Qnil
;
1309 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1311 Lisp_Object args
[2];
1313 /* We are visiting windows in canonical order, and add
1314 new windows at the front of args[1], which means we
1315 have to reverse this list at the end. */
1317 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1318 args
[0] = Vwindow_list
;
1319 args
[1] = Fnreverse (args
[1]);
1320 Vwindow_list
= Fnconc (2, args
);
1324 return Vwindow_list
;
1328 /* Value is non-zero if WINDOW satisfies the constraints given by
1329 OWINDOW, MINIBUF and ALL_FRAMES.
1331 MINIBUF t means WINDOW may be minibuffer windows.
1332 `lambda' means WINDOW may not be a minibuffer window.
1333 a window means a specific minibuffer window
1335 ALL_FRAMES t means search all frames,
1336 nil means search just current frame,
1337 `visible' means search just visible frames,
1338 0 means search visible and iconified frames,
1339 a window means search the frame that window belongs to,
1340 a frame means consider windows on that frame, only. */
1343 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1344 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1346 struct window
*w
= XWINDOW (window
);
1347 struct frame
*f
= XFRAME (w
->frame
);
1348 int candidate_p
= 1;
1350 if (!BUFFERP (w
->buffer
))
1352 else if (MINI_WINDOW_P (w
)
1353 && (EQ (minibuf
, Qlambda
)
1354 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1356 /* If MINIBUF is `lambda' don't consider any mini-windows.
1357 If it is a window, consider only that one. */
1360 else if (EQ (all_frames
, Qt
))
1362 else if (NILP (all_frames
))
1364 xassert (WINDOWP (owindow
));
1365 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1367 else if (EQ (all_frames
, Qvisible
))
1369 FRAME_SAMPLE_VISIBILITY (f
);
1370 candidate_p
= FRAME_VISIBLE_P (f
);
1372 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1374 FRAME_SAMPLE_VISIBILITY (f
);
1375 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1377 else if (WINDOWP (all_frames
))
1378 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1379 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1380 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1381 else if (FRAMEP (all_frames
))
1382 candidate_p
= EQ (all_frames
, w
->frame
);
1388 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1389 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1393 decode_next_window_args (window
, minibuf
, all_frames
)
1394 Lisp_Object
*window
, *minibuf
, *all_frames
;
1397 *window
= selected_window
;
1399 CHECK_LIVE_WINDOW (*window
, 0);
1401 /* MINIBUF nil may or may not include minibuffers. Decide if it
1403 if (NILP (*minibuf
))
1404 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1405 else if (!EQ (*minibuf
, Qt
))
1408 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1409 => count none of them, or a specific minibuffer window (the
1410 active one) to count. */
1412 /* ALL_FRAMES nil doesn't specify which frames to include. */
1413 if (NILP (*all_frames
))
1414 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1415 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1417 else if (EQ (*all_frames
, Qvisible
))
1419 else if (XFASTINT (*all_frames
) == 0)
1421 else if (FRAMEP (*all_frames
))
1423 else if (!EQ (*all_frames
, Qt
))
1426 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1427 search just current frame, `visible' meaning search just visible
1428 frames, 0 meaning search visible and iconified frames, or a
1429 window, meaning search the frame that window belongs to, or a
1430 frame, meaning consider windows on that frame, only. */
1434 /* Return the next or previous window of WINDOW in canonical ordering
1435 of windows. NEXT_P non-zero means return the next window. See the
1436 documentation string of next-window for the meaning of MINIBUF and
1440 next_window (window
, minibuf
, all_frames
, next_p
)
1441 Lisp_Object window
, minibuf
, all_frames
;
1444 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1446 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1447 return the first window on the frame. */
1448 if (FRAMEP (all_frames
)
1449 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1450 return Fframe_first_window (all_frames
);
1456 /* Find WINDOW in the list of all windows. */
1457 list
= Fmemq (window
, window_list ());
1459 /* Scan forward from WINDOW to the end of the window list. */
1461 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1462 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1465 /* Scan from the start of the window list up to WINDOW. */
1467 for (list
= Vwindow_list
;
1468 CONSP (list
) && !EQ (XCAR (list
), window
);
1470 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1474 window
= XCAR (list
);
1478 Lisp_Object candidate
, list
;
1480 /* Scan through the list of windows for candidates. If there are
1481 candidate windows in front of WINDOW, the last one of these
1482 is the one we want. If there are candidates following WINDOW
1483 in the list, again the last one of these is the one we want. */
1485 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1487 if (EQ (XCAR (list
), window
))
1489 if (WINDOWP (candidate
))
1492 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1494 candidate
= XCAR (list
);
1497 if (WINDOWP (candidate
))
1505 /* This comment supplies the doc string for `next-window',
1506 for make-docfile to see. We cannot put this in the real DEFUN
1507 due to limits in the Unix cpp.
1509 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
1510 "Return next window after WINDOW in canonical ordering of windows.\n\
1511 If omitted, WINDOW defaults to the selected window.\n\
1513 Optional second arg MINIBUF t means count the minibuffer window even\n\
1514 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1515 it is active. MINIBUF neither t nor nil means not to count the\n\
1516 minibuffer even if it is active.\n\
1518 Several frames may share a single minibuffer; if the minibuffer\n\
1519 counts, all windows on all frames that share that minibuffer count\n\
1520 too. Therefore, `next-window' can be used to iterate through the\n\
1521 set of windows even when the minibuffer is on another frame. If the\n\
1522 minibuffer does not count, only windows from WINDOW's frame count.\n\
1524 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1525 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1526 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1527 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1528 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
1529 Anything else means restrict to WINDOW's frame.\n\
1531 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1532 `next-window' to iterate through the entire cycle of acceptable\n\
1533 windows, eventually ending up back at the window you started with.\n\
1534 `previous-window' traverses the same cycle, in the reverse order.")
1535 (window, minibuf, all_frames) */
1537 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1539 (window
, minibuf
, all_frames
)
1540 Lisp_Object window
, minibuf
, all_frames
;
1542 return next_window (window
, minibuf
, all_frames
, 1);
1546 /* This comment supplies the doc string for `previous-window',
1547 for make-docfile to see. We cannot put this in the real DEFUN
1548 due to limits in the Unix cpp.
1550 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
1551 "Return the window preceding WINDOW in canonical ordering of windows.\n\
1552 If omitted, WINDOW defaults to the selected window.\n\
1554 Optional second arg MINIBUF t means count the minibuffer window even\n\
1555 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1556 it is active. MINIBUF neither t nor nil means not to count the\n\
1557 minibuffer even if it is active.\n\
1559 Several frames may share a single minibuffer; if the minibuffer\n\
1560 counts, all windows on all frames that share that minibuffer count\n\
1561 too. Therefore, `previous-window' can be used to iterate through\n\
1562 the set of windows even when the minibuffer is on another frame. If\n\
1563 the minibuffer does not count, only windows from WINDOW's frame count\n\
1565 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1566 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1567 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1568 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1569 If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
1570 Anything else means restrict to WINDOW's frame.\n\
1572 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1573 `previous-window' to iterate through the entire cycle of acceptable\n\
1574 windows, eventually ending up back at the window you started with.\n\
1575 `next-window' traverses the same cycle, in the reverse order.")
1576 (window, minibuf, all_frames) */
1579 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1581 (window
, minibuf
, all_frames
)
1582 Lisp_Object window
, minibuf
, all_frames
;
1584 return next_window (window
, minibuf
, all_frames
, 0);
1588 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1589 "Select the ARG'th different window on this frame.\n\
1590 All windows on current frame are arranged in a cyclic order.\n\
1591 This command selects the window ARG steps away in that order.\n\
1592 A negative ARG moves in the opposite order. If the optional second\n\
1593 argument ALL_FRAMES is non-nil, cycle through all frames.")
1595 Lisp_Object arg
, all_frames
;
1600 CHECK_NUMBER (arg
, 0);
1601 window
= selected_window
;
1603 for (i
= XINT (arg
); i
> 0; --i
)
1604 window
= Fnext_window (window
, Qnil
, all_frames
);
1606 window
= Fprevious_window (window
, Qnil
, all_frames
);
1608 Fselect_window (window
);
1613 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1614 "Return a list of windows on FRAME, starting with WINDOW.\n\
1615 FRAME nil or omitted means use the selected frame.\n\
1616 WINDOW nil or omitted means use the selected window.\n\
1617 MINIBUF t means include the minibuffer window, even if it isn't active.\n\
1618 MINIBUF nil or omitted means include the minibuffer window only\n\
1620 MINIBUF neither nil nor t means never include the minibuffer window.")
1621 (frame
, minibuf
, window
)
1622 Lisp_Object frame
, minibuf
, window
;
1627 window
= selected_window
;
1629 frame
= selected_frame
;
1631 if (!EQ (frame
, XWINDOW (window
)->frame
))
1632 error ("Window is on a different frame");
1634 return window_list_1 (window
, minibuf
, frame
);
1638 /* Return a list of windows in canonical ordering. Arguments are like
1639 for `next-window'. */
1642 window_list_1 (window
, minibuf
, all_frames
)
1643 Lisp_Object window
, minibuf
, all_frames
;
1645 Lisp_Object tail
, list
;
1647 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1650 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1651 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1652 list
= Fcons (XCAR (tail
), list
);
1654 return Fnreverse (list
);
1659 /* Look at all windows, performing an operation specified by TYPE
1661 If FRAMES is Qt, look at all frames;
1662 Qnil, look at just the selected frame;
1663 Qvisible, look at visible frames;
1664 a frame, just look at windows on that frame.
1665 If MINI is non-zero, perform the operation on minibuffer windows too.
1671 GET_BUFFER_WINDOW
, /* Arg is buffer */
1672 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1673 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1674 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1676 UNSHOW_BUFFER
, /* Arg is buffer */
1681 window_loop (type
, obj
, mini
, frames
)
1682 enum window_loop type
;
1683 Lisp_Object obj
, frames
;
1686 Lisp_Object window
, windows
, best_window
, frame_arg
;
1688 struct gcpro gcpro1
;
1690 /* If we're only looping through windows on a particular frame,
1691 frame points to that frame. If we're looping through windows
1692 on all frames, frame is 0. */
1693 if (FRAMEP (frames
))
1694 f
= XFRAME (frames
);
1695 else if (NILP (frames
))
1696 f
= SELECTED_FRAME ();
1701 frame_arg
= Qlambda
;
1702 else if (XFASTINT (frames
) == 0)
1704 else if (EQ (frames
, Qvisible
))
1709 /* frame_arg is Qlambda to stick to one frame,
1710 Qvisible to consider all visible frames,
1713 /* Pick a window to start with. */
1717 window
= FRAME_SELECTED_WINDOW (f
);
1719 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1721 /* Figure out the last window we're going to mess with. Since
1722 Fnext_window, given the same options, is guaranteed to go in a
1723 ring, we can just use Fprevious_window to find the last one.
1725 We can't just wait until we hit the first window again, because
1726 it might be deleted. */
1728 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1732 for (; CONSP (windows
); windows
= CDR (windows
))
1736 window
= XCAR (windows
);
1737 w
= XWINDOW (window
);
1739 /* Note that we do not pay attention here to whether the frame
1740 is visible, since Fwindow_list skips non-visible frames if
1741 that is desired, under the control of frame_arg. */
1742 if (!MINI_WINDOW_P (w
)
1743 /* For UNSHOW_BUFFER, we must always consider all windows. */
1744 || type
== UNSHOW_BUFFER
1745 || (mini
&& minibuf_level
> 0))
1748 case GET_BUFFER_WINDOW
:
1749 if (EQ (w
->buffer
, obj
)
1750 /* Don't find any minibuffer window
1751 except the one that is currently in use. */
1752 && (MINI_WINDOW_P (w
)
1753 ? EQ (window
, minibuf_window
)
1761 case GET_LRU_WINDOW
:
1762 /* t as arg means consider only full-width windows */
1763 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1765 /* Ignore dedicated windows and minibuffers. */
1766 if (MINI_WINDOW_P (w
) || !NILP (w
->dedicated
))
1768 if (NILP (best_window
)
1769 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1770 > XFASTINT (w
->use_time
)))
1771 best_window
= window
;
1774 case DELETE_OTHER_WINDOWS
:
1775 if (!EQ (window
, obj
))
1776 Fdelete_window (window
);
1779 case DELETE_BUFFER_WINDOWS
:
1780 if (EQ (w
->buffer
, obj
))
1782 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1784 /* If this window is dedicated, and in a frame of its own,
1786 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1787 && !NILP (w
->dedicated
)
1788 && other_visible_frames (f
))
1790 /* Skip the other windows on this frame.
1791 There might be one, the minibuffer! */
1792 while (CONSP (XCDR (windows
))
1793 && EQ (XWINDOW (XCAR (windows
))->frame
,
1794 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1795 windows
= XCDR (windows
);
1797 /* Now we can safely delete the frame. */
1798 Fdelete_frame (w
->frame
, Qnil
);
1800 else if (NILP (w
->parent
))
1802 /* If we're deleting the buffer displayed in the
1803 only window on the frame, find a new buffer to
1806 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1808 buffer
= Fget_buffer_create (build_string ("*scratch*"));
1809 Fset_window_buffer (window
, buffer
);
1810 if (EQ (window
, selected_window
))
1811 Fset_buffer (w
->buffer
);
1814 Fdelete_window (window
);
1818 case GET_LARGEST_WINDOW
:
1820 /* Ignore dedicated windows and minibuffers. */
1821 if (MINI_WINDOW_P (w
) || !NILP (w
->dedicated
))
1824 if (NILP (best_window
))
1825 best_window
= window
;
1828 struct window
*b
= XWINDOW (best_window
);
1829 if (XFASTINT (w
->height
) * XFASTINT (w
->width
)
1830 > XFASTINT (b
->height
) * XFASTINT (b
->width
))
1831 best_window
= window
;
1837 if (EQ (w
->buffer
, obj
))
1840 struct frame
*f
= XFRAME (w
->frame
);
1842 /* Find another buffer to show in this window. */
1843 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1845 buffer
= Fget_buffer_create (build_string ("*scratch*"));
1847 /* If this window is dedicated, and in a frame of its own,
1849 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1850 && !NILP (w
->dedicated
)
1851 && other_visible_frames (f
))
1853 /* Skip the other windows on this frame.
1854 There might be one, the minibuffer! */
1855 while (CONSP (XCDR (windows
))
1856 && EQ (XWINDOW (XCAR (windows
))->frame
,
1857 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1858 windows
= XCDR (windows
);
1860 /* Now we can safely delete the frame. */
1861 Fdelete_frame (w
->frame
, Qnil
);
1865 /* Otherwise show a different buffer in the window. */
1866 w
->dedicated
= Qnil
;
1867 Fset_window_buffer (window
, buffer
);
1868 if (EQ (window
, selected_window
))
1869 Fset_buffer (w
->buffer
);
1874 /* Check for a window that has a killed buffer. */
1875 case CHECK_ALL_WINDOWS
:
1876 if (! NILP (w
->buffer
)
1877 && NILP (XBUFFER (w
->buffer
)->name
))
1881 case WINDOW_LOOP_UNUSED
:
1890 /* Used for debugging. Abort if any window has a dead buffer. */
1893 check_all_windows ()
1895 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
1898 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1899 "Return the window least recently selected or used for display.\n\
1900 If optional argument FRAME is `visible', search all visible frames.\n\
1901 If FRAME is 0, search all visible and iconified frames.\n\
1902 If FRAME is t, search all frames.\n\
1903 If FRAME is nil, search only the selected frame.\n\
1904 If FRAME is a frame, search only that frame.")
1908 register Lisp_Object w
;
1909 /* First try for a window that is full-width */
1910 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1911 if (!NILP (w
) && !EQ (w
, selected_window
))
1913 /* If none of them, try the rest */
1914 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1917 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1918 "Return the largest window in area.\n\
1919 If optional argument FRAME is `visible', search all visible frames.\n\
1920 If FRAME is 0, search all visible and iconified frames.\n\
1921 If FRAME is t, search all frames.\n\
1922 If FRAME is nil, search only the selected frame.\n\
1923 If FRAME is a frame, search only that frame.")
1927 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1931 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1932 "Return a window currently displaying BUFFER, or nil if none.\n\
1933 If optional argument FRAME is `visible', search all visible frames.\n\
1934 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1935 If FRAME is t, search all frames.\n\
1936 If FRAME is nil, search only the selected frame.\n\
1937 If FRAME is a frame, search only that frame.")
1939 Lisp_Object buffer
, frame
;
1941 buffer
= Fget_buffer (buffer
);
1942 if (BUFFERP (buffer
))
1943 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1948 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1950 "Make WINDOW (or the selected window) fill its frame.\n\
1951 Only the frame WINDOW is on is affected.\n\
1952 This function tries to reduce display jumps\n\
1953 by keeping the text previously visible in WINDOW\n\
1954 in the same place on the frame. Doing this depends on\n\
1955 the value of (window-start WINDOW), so if calling this function\n\
1956 in a program gives strange scrolling, make sure the window-start\n\
1957 value is reasonable when this function is called.")
1966 window
= selected_window
;
1968 CHECK_LIVE_WINDOW (window
, 0);
1970 w
= XWINDOW (window
);
1972 startpos
= marker_position (w
->start
);
1973 top
= XFASTINT (w
->top
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
1975 if (MINI_WINDOW_P (w
) && top
> 0)
1976 error ("Can't expand minibuffer to full frame");
1978 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1980 /* Try to minimize scrolling, by setting the window start to the point
1981 will cause the text at the old window start to be at the same place
1982 on the frame. But don't try to do this if the window start is
1983 outside the visible portion (as might happen when the display is
1984 not current, due to typeahead). */
1985 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1986 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1988 struct position pos
;
1989 struct buffer
*obuf
= current_buffer
;
1991 Fset_buffer (w
->buffer
);
1992 /* This computation used to temporarily move point, but that can
1993 have unwanted side effects due to text properties. */
1994 pos
= *vmotion (startpos
, -top
, w
);
1996 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
1997 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
1998 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2000 /* We need to do this, so that the window-scroll-functions
2002 w
->optional_new_start
= Qt
;
2004 set_buffer_internal (obuf
);
2010 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2011 1, 2, "bDelete windows on (buffer): ",
2012 "Delete all windows showing BUFFER.\n\
2013 Optional second argument FRAME controls which frames are affected.\n\
2014 If optional argument FRAME is `visible', search all visible frames.\n\
2015 If FRAME is 0, search all visible and iconified frames.\n\
2016 If FRAME is nil, search all frames.\n\
2017 If FRAME is t, search only the selected frame.\n\
2018 If FRAME is a frame, search only that frame.")
2020 Lisp_Object buffer
, frame
;
2022 /* FRAME uses t and nil to mean the opposite of what window_loop
2026 else if (EQ (frame
, Qt
))
2031 buffer
= Fget_buffer (buffer
);
2032 CHECK_BUFFER (buffer
, 0);
2033 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2039 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2040 Sreplace_buffer_in_windows
,
2041 1, 1, "bReplace buffer in windows: ",
2042 "Replace BUFFER with some other buffer in all windows showing it.")
2048 buffer
= Fget_buffer (buffer
);
2049 CHECK_BUFFER (buffer
, 0);
2050 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2055 /* Replace BUFFER with some other buffer in all windows
2056 of all frames, even those on other keyboards. */
2059 replace_buffer_in_all_windows (buffer
)
2063 Lisp_Object tail
, frame
;
2065 /* A single call to window_loop won't do the job
2066 because it only considers frames on the current keyboard.
2067 So loop manually over frames, and handle each one. */
2068 FOR_EACH_FRAME (tail
, frame
)
2069 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2071 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2075 /* Set the height of WINDOW and all its inferiors. */
2077 /* The smallest acceptable dimensions for a window. Anything smaller
2078 might crash Emacs. */
2080 #define MIN_SAFE_WINDOW_WIDTH (2)
2081 #define MIN_SAFE_WINDOW_HEIGHT (2)
2083 /* Make sure that window_min_height and window_min_width are
2084 not too small; if they are, set them to safe minima. */
2087 check_min_window_sizes ()
2089 /* Smaller values might permit a crash. */
2090 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2091 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2092 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2093 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2096 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2097 minimum allowable size. */
2100 check_frame_size (frame
, rows
, cols
)
2104 /* For height, we have to see:
2105 whether the frame has a minibuffer,
2106 whether it wants a mode line, and
2107 whether it has a menu bar. */
2109 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
2110 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
2111 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
2113 if (FRAME_TOP_MARGIN (frame
) > 0)
2114 min_height
+= FRAME_TOP_MARGIN (frame
);
2116 if (*rows
< min_height
)
2118 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2119 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2123 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2124 check if W's width can be changed, otherwise check W's height.
2125 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2126 siblings, too. If none of the siblings is resizable, WINDOW isn't
2130 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2132 int width_p
, check_siblings_p
;
2137 if (!NILP (w
->hchild
))
2139 c
= XWINDOW (w
->hchild
);
2143 /* A horiz. combination is fixed-width if all of if its
2145 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2146 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2147 fixed_p
= c
== NULL
;
2151 /* A horiz. combination is fixed-height if one of if its
2153 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2154 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2155 fixed_p
= c
!= NULL
;
2158 else if (!NILP (w
->vchild
))
2160 c
= XWINDOW (w
->vchild
);
2164 /* A vert. combination is fixed-width if one of if its
2166 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2167 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2168 fixed_p
= c
!= NULL
;
2172 /* A vert. combination is fixed-height if all of if its
2174 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2175 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2176 fixed_p
= c
== NULL
;
2179 else if (BUFFERP (w
->buffer
))
2181 if (w
->height_fixed_p
&& !width_p
)
2185 struct buffer
*old
= current_buffer
;
2188 current_buffer
= XBUFFER (w
->buffer
);
2189 val
= find_symbol_value (Qwindow_size_fixed
);
2190 current_buffer
= old
;
2193 if (!EQ (val
, Qunbound
))
2195 fixed_p
= !NILP (val
);
2198 && ((EQ (val
, Qheight
) && width_p
)
2199 || (EQ (val
, Qwidth
) && !width_p
)))
2204 /* Can't tell if this one is resizable without looking at
2205 siblings. If all siblings are fixed-size this one is too. */
2206 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2210 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2211 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2215 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2216 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2230 /* Return the minimum size of window W, not taking fixed-width windows
2231 into account. WIDTH_P non-zero means return the minimum width,
2232 otherwise return the minimum height. If W is a combination window,
2233 compute the minimum size from the minimum sizes of W's children. */
2236 window_min_size_1 (w
, width_p
)
2243 if (!NILP (w
->hchild
))
2245 c
= XWINDOW (w
->hchild
);
2250 /* The min width of a horizontal combination is
2251 the sum of the min widths of its children. */
2254 size
+= window_min_size_1 (c
, width_p
);
2255 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2260 /* The min height a horizontal combination equals
2261 the maximum of all min height of its children. */
2264 int min_size
= window_min_size_1 (c
, width_p
);
2265 size
= max (min_size
, size
);
2266 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2270 else if (!NILP (w
->vchild
))
2272 c
= XWINDOW (w
->vchild
);
2277 /* The min width of a vertical combination is
2278 the maximum of the min widths of its children. */
2281 int min_size
= window_min_size_1 (c
, width_p
);
2282 size
= max (min_size
, size
);
2283 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2288 /* The min height of a vertical combination equals
2289 the sum of the min height of its children. */
2292 size
+= window_min_size_1 (c
, width_p
);
2293 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2300 size
= window_min_width
;
2303 if (MINI_WINDOW_P (w
)
2304 || (!WINDOW_WANTS_MODELINE_P (w
)
2305 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2308 size
= window_min_height
;
2316 /* Return the minimum size of window W, taking fixed-size windows into
2317 account. WIDTH_P non-zero means return the minimum width,
2318 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2319 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2320 unless FIXED is null. */
2323 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2325 int width_p
, ignore_fixed_p
, *fixed
;
2332 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2338 size
= width_p
? XFASTINT (w
->width
) : XFASTINT (w
->height
);
2340 size
= window_min_size_1 (w
, width_p
);
2346 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2347 WINDOW's width. Resize WINDOW's children, if any, so that they
2348 keep their proportionate size relative to WINDOW. Propagate
2349 WINDOW's top or left edge position to children. Delete windows
2350 that become too small unless NODELETE_P is non-zero. */
2353 size_window (window
, size
, width_p
, nodelete_p
)
2355 int size
, width_p
, nodelete_p
;
2357 struct window
*w
= XWINDOW (window
);
2359 Lisp_Object child
, *forward
, *sideward
;
2360 int old_size
, min_size
;
2362 check_min_window_sizes ();
2363 size
= max (0, size
);
2365 /* If the window has been "too small" at one point,
2366 don't delete it for being "too small" in the future.
2367 Preserve it as long as that is at all possible. */
2370 old_size
= XINT (w
->width
);
2371 min_size
= window_min_width
;
2375 old_size
= XINT (w
->height
);
2376 min_size
= window_min_height
;
2379 if (old_size
< window_min_width
)
2380 w
->too_small_ok
= Qt
;
2382 /* Maybe delete WINDOW if it's too small. */
2383 if (!nodelete_p
&& !NILP (w
->parent
))
2387 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2388 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2390 min_size
= width_p
? window_min_width
: window_min_height
;
2392 if (size
< min_size
)
2394 delete_window (window
);
2399 /* Set redisplay hints. */
2400 w
->last_modified
= make_number (0);
2401 w
->last_overlay_modified
= make_number (0);
2402 windows_or_buffers_changed
++;
2403 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2407 sideward
= &w
->vchild
;
2408 forward
= &w
->hchild
;
2409 w
->width
= make_number (size
);
2413 sideward
= &w
->hchild
;
2414 forward
= &w
->vchild
;
2415 w
->height
= make_number (size
);
2418 if (!NILP (*sideward
))
2420 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2422 c
= XWINDOW (child
);
2427 size_window (child
, size
, width_p
, nodelete_p
);
2430 else if (!NILP (*forward
))
2432 int fixed_size
, each
, extra
, n
;
2433 int resize_fixed_p
, nfixed
;
2434 int last_pos
, first_pos
, nchildren
, total
;
2436 /* Determine the fixed-size portion of the this window, and the
2437 number of child windows. */
2438 fixed_size
= nchildren
= nfixed
= total
= 0;
2439 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2443 c
= XWINDOW (child
);
2444 child_size
= width_p
? XINT (c
->width
) : XINT (c
->height
);
2445 total
+= child_size
;
2447 if (window_fixed_size_p (c
, width_p
, 0))
2449 fixed_size
+= child_size
;
2454 /* If the new size is smaller than fixed_size, or if there
2455 aren't any resizable windows, allow resizing fixed-size
2457 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2459 /* Compute how many lines/columns to add to each child. The
2460 value of extra takes care of rounding errors. */
2461 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2462 each
= (size
- total
) / n
;
2463 extra
= (size
- total
) - n
* each
;
2465 /* Compute new children heights and edge positions. */
2466 first_pos
= width_p
? XINT (w
->left
) : XINT (w
->top
);
2467 last_pos
= first_pos
;
2468 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2470 int new_size
, old_size
;
2472 c
= XWINDOW (child
);
2473 old_size
= width_p
? XFASTINT (c
->width
) : XFASTINT (c
->height
);
2474 new_size
= old_size
;
2476 /* The top or left edge position of this child equals the
2477 bottom or right edge of its predecessor. */
2479 c
->left
= make_number (last_pos
);
2481 c
->top
= make_number (last_pos
);
2483 /* If this child can be resized, do it. */
2484 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2486 new_size
= old_size
+ each
+ extra
;
2490 /* Set new height. Note that size_window also propagates
2491 edge positions to children, so it's not a no-op if we
2492 didn't change the child's size. */
2493 size_window (child
, new_size
, width_p
, 1);
2495 /* Remember the bottom/right edge position of this child; it
2496 will be used to set the top/left edge of the next child. */
2497 last_pos
+= new_size
;
2500 /* We should have covered the parent exactly with child windows. */
2501 xassert (size
== last_pos
- first_pos
);
2503 /* Now delete any children that became too small. */
2505 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2508 c
= XWINDOW (child
);
2509 child_size
= width_p
? XINT (c
->width
) : XINT (c
->height
);
2510 size_window (child
, child_size
, width_p
, 0);
2515 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2516 WINDOW's children. NODELETE non-zero means don't delete windows
2517 that become too small in the process. (The caller should check
2518 later and do so if appropriate.) */
2521 set_window_height (window
, height
, nodelete
)
2526 size_window (window
, height
, 0, nodelete
);
2530 /* Set WINDOW's width to WIDTH, and recursively change the width of
2531 WINDOW's children. NODELETE non-zero means don't delete windows
2532 that become too small in the process. (The caller should check
2533 later and do so if appropriate.) */
2536 set_window_width (window
, width
, nodelete
)
2541 size_window (window
, width
, 1, nodelete
);
2545 int window_select_count
;
2548 Fset_window_buffer_unwind (obuf
)
2556 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2557 means it's allowed to run hooks. See make_frame for a case where
2558 it's not allowed. */
2561 set_window_buffer (window
, buffer
, run_hooks_p
)
2562 Lisp_Object window
, buffer
;
2565 struct window
*w
= XWINDOW (window
);
2566 struct buffer
*b
= XBUFFER (buffer
);
2567 int count
= specpdl_ptr
- specpdl
;
2571 if (EQ (window
, selected_window
))
2572 b
->last_selected_window
= window
;
2574 /* Update time stamps of buffer display. */
2575 if (INTEGERP (b
->display_count
))
2576 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
2577 b
->display_time
= Fcurrent_time ();
2579 XSETFASTINT (w
->window_end_pos
, 0);
2580 XSETFASTINT (w
->window_end_vpos
, 0);
2581 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
2582 w
->window_end_valid
= Qnil
;
2583 XSETFASTINT (w
->hscroll
, 0);
2584 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
2585 set_marker_restricted (w
->start
,
2586 make_number (b
->last_window_start
),
2588 w
->start_at_line_beg
= Qnil
;
2589 w
->force_start
= Qnil
;
2590 XSETFASTINT (w
->last_modified
, 0);
2591 XSETFASTINT (w
->last_overlay_modified
, 0);
2592 windows_or_buffers_changed
++;
2594 /* We must select BUFFER for running the window-scroll-functions.
2595 If WINDOW is selected, switch permanently.
2596 Otherwise, switch but go back to the ambient buffer afterward. */
2597 if (EQ (window
, selected_window
))
2598 Fset_buffer (buffer
);
2599 /* We can't check ! NILP (Vwindow_scroll_functions) here
2600 because that might itself be a local variable. */
2601 else if (window_initialized
)
2603 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
2604 Fset_buffer (buffer
);
2607 /* Set left and right marginal area width from buffer. */
2608 Fset_window_margins (window
, b
->left_margin_width
, b
->right_margin_width
);
2612 if (! NILP (Vwindow_scroll_functions
))
2613 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2614 Fmarker_position (w
->start
));
2616 if (! NILP (Vwindow_configuration_change_hook
)
2617 && ! NILP (Vrun_hooks
))
2618 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
2621 unbind_to (count
, Qnil
);
2625 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
2626 "Make WINDOW display BUFFER as its contents.\n\
2627 BUFFER can be a buffer or buffer name.")
2629 register Lisp_Object window
, buffer
;
2631 register Lisp_Object tem
;
2632 register struct window
*w
= decode_window (window
);
2634 XSETWINDOW (window
, w
);
2635 buffer
= Fget_buffer (buffer
);
2636 CHECK_BUFFER (buffer
, 1);
2638 if (NILP (XBUFFER (buffer
)->name
))
2639 error ("Attempt to display deleted buffer");
2643 error ("Window is deleted");
2644 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
2645 is first being set up. */
2647 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
2648 error ("Window is dedicated to `%s'",
2649 XSTRING (XBUFFER (tem
)->name
)->data
);
2654 set_window_buffer (window
, buffer
, 1);
2658 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
2659 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
2660 If WINDOW is not already selected, also make WINDOW's buffer current.\n\
2661 Note that the main editor command loop\n\
2662 selects the buffer of the selected window before each command.")
2664 register Lisp_Object window
;
2666 return select_window_1 (window
, 1);
2669 /* Note that selected_window can be nil
2670 when this is called from Fset_window_configuration. */
2673 select_window_1 (window
, recordflag
)
2674 register Lisp_Object window
;
2677 register struct window
*w
;
2678 register struct window
*ow
;
2681 CHECK_LIVE_WINDOW (window
, 0);
2683 w
= XWINDOW (window
);
2685 if (NILP (w
->buffer
))
2686 error ("Trying to select deleted window or non-leaf window");
2688 XSETFASTINT (w
->use_time
, ++window_select_count
);
2689 if (EQ (window
, selected_window
))
2692 if (!NILP (selected_window
))
2694 ow
= XWINDOW (selected_window
);
2695 if (! NILP (ow
->buffer
))
2696 set_marker_both (ow
->pointm
, ow
->buffer
,
2697 BUF_PT (XBUFFER (ow
->buffer
)),
2698 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
2701 selected_window
= window
;
2702 sf
= SELECTED_FRAME ();
2703 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
2705 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
2706 /* Use this rather than Fhandle_switch_frame
2707 so that FRAME_FOCUS_FRAME is moved appropriately as we
2708 move around in the state where a minibuffer in a separate
2710 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
2713 sf
->selected_window
= window
;
2716 record_buffer (w
->buffer
);
2717 Fset_buffer (w
->buffer
);
2719 XBUFFER (w
->buffer
)->last_selected_window
= window
;
2721 /* Go to the point recorded in the window.
2722 This is important when the buffer is in more
2723 than one window. It also matters when
2724 redisplay_window has altered point after scrolling,
2725 because it makes the change only in the window. */
2727 register int new_point
= marker_position (w
->pointm
);
2728 if (new_point
< BEGV
)
2730 else if (new_point
> ZV
)
2736 windows_or_buffers_changed
++;
2740 /* Deiconify the frame containing the window WINDOW,
2741 unless it is the selected frame;
2744 The reason for the exception for the selected frame
2745 is that it seems better not to change the selected frames visibility
2746 merely because of displaying a different buffer in it.
2747 The deiconification is useful when a buffer gets shown in
2748 another frame that you were not using lately. */
2751 display_buffer_1 (window
)
2754 Lisp_Object frame
= XWINDOW (window
)->frame
;
2755 FRAME_PTR f
= XFRAME (frame
);
2757 FRAME_SAMPLE_VISIBILITY (f
);
2759 if (!EQ (frame
, selected_frame
))
2761 if (FRAME_ICONIFIED_P (f
))
2762 Fmake_frame_visible (frame
);
2763 else if (FRAME_VISIBLE_P (f
))
2764 Fraise_frame (frame
);
2770 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
2771 "Returns non-nil if a buffer named BUFFER-NAME would be created specially.\n\
2772 The value is actually t if the frame should be called with default frame\n\
2773 parameters, and a list of frame parameters if they were specified.\n\
2774 See `special-display-buffer-names', and `special-display-regexps'.")
2776 Lisp_Object buffer_name
;
2780 CHECK_STRING (buffer_name
, 1);
2782 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
2786 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
2790 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2792 Lisp_Object car
= XCAR (tem
);
2794 && fast_string_match (car
, buffer_name
) >= 0)
2796 else if (CONSP (car
)
2797 && STRINGP (XCAR (car
))
2798 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2804 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
2805 "Returns non-nil if a new buffer named BUFFER-NAME would use the same window.\n\
2806 See `same-window-buffer-names' and `same-window-regexps'.")
2808 Lisp_Object buffer_name
;
2812 CHECK_STRING (buffer_name
, 1);
2814 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
2818 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
2822 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2824 Lisp_Object car
= XCAR (tem
);
2826 && fast_string_match (car
, buffer_name
) >= 0)
2828 else if (CONSP (car
)
2829 && STRINGP (XCAR (car
))
2830 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2836 /* Use B so the default is (other-buffer). */
2837 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
2838 "BDisplay buffer: \nP",
2839 "Make BUFFER appear in some window but don't select it.\n\
2840 BUFFER can be a buffer or a buffer name.\n\
2841 If BUFFER is shown already in some window, just use that one,\n\
2842 unless the window is the selected window and the optional second\n\
2843 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
2844 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
2845 Returns the window displaying BUFFER.\n\
2846 If `display-reuse-frames' is non-nil, and another frame is currently\n\
2847 displaying BUFFER, then simply raise that frame.\n\
2849 The variables `special-display-buffer-names', `special-display-regexps',\n\
2850 `same-window-buffer-names', and `same-window-regexps' customize how certain\n\
2851 buffer names are handled.\n\
2853 If optional argument FRAME is `visible', search all visible frames.\n\
2854 If FRAME is 0, search all visible and iconified frames.\n\
2855 If FRAME is t, search all frames.\n\
2856 If FRAME is a frame, search only that frame.\n\
2857 If FRAME is nil, search only the selected frame\n\
2858 (actually the last nonminibuffer frame),\n\
2859 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,\n\
2860 which means search visible and iconified frames.\n\
2862 If `even-window-heights' is non-nil, window heights will be evened out\n\
2863 if displaying the buffer causes two vertically\ adjacent windows to be\n\
2865 (buffer
, not_this_window
, frame
)
2866 register Lisp_Object buffer
, not_this_window
, frame
;
2868 register Lisp_Object window
, tem
, swp
;
2872 buffer
= Fget_buffer (buffer
);
2873 CHECK_BUFFER (buffer
, 0);
2875 if (!NILP (Vdisplay_buffer_function
))
2876 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
2878 if (NILP (not_this_window
)
2879 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
2880 return display_buffer_1 (selected_window
);
2882 /* See if the user has specified this buffer should appear
2883 in the selected window. */
2884 if (NILP (not_this_window
))
2886 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
2887 if (!NILP (swp
) && !no_switch_window (selected_window
))
2889 Fswitch_to_buffer (buffer
, Qnil
);
2890 return display_buffer_1 (selected_window
);
2894 /* If the user wants pop-up-frames or display-reuse-frames, then
2895 look for a window showing BUFFER on any visible or iconified frame.
2896 Otherwise search only the current frame. */
2899 else if (pop_up_frames
2900 || display_buffer_reuse_frames
2901 || last_nonminibuf_frame
== 0)
2902 XSETFASTINT (tem
, 0);
2904 XSETFRAME (tem
, last_nonminibuf_frame
);
2906 window
= Fget_buffer_window (buffer
, tem
);
2908 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
2909 return display_buffer_1 (window
);
2911 /* Certain buffer names get special handling. */
2912 if (!NILP (Vspecial_display_function
) && NILP (swp
))
2914 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
2916 return call1 (Vspecial_display_function
, buffer
);
2918 return call2 (Vspecial_display_function
, buffer
, tem
);
2921 /* If there are no frames open that have more than a minibuffer,
2922 we need to create a new frame. */
2923 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
2925 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2926 Fset_window_buffer (window
, buffer
);
2927 return display_buffer_1 (window
);
2930 f
= SELECTED_FRAME ();
2932 || FRAME_MINIBUF_ONLY_P (f
)
2933 /* If the current frame is a special display frame,
2934 don't try to reuse its windows. */
2935 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
2940 if (FRAME_MINIBUF_ONLY_P (f
))
2941 XSETFRAME (frames
, last_nonminibuf_frame
);
2942 /* Don't try to create a window if would get an error */
2943 if (split_height_threshold
< window_min_height
<< 1)
2944 split_height_threshold
= window_min_height
<< 1;
2946 /* Note that both Fget_largest_window and Fget_lru_window
2947 ignore minibuffers and dedicated windows.
2948 This means they can return nil. */
2950 /* If the frame we would try to split cannot be split,
2951 try other frames. */
2952 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
2954 /* Try visible frames first. */
2955 window
= Fget_largest_window (Qvisible
);
2956 /* If that didn't work, try iconified frames. */
2958 window
= Fget_largest_window (make_number (0));
2960 window
= Fget_largest_window (Qt
);
2963 window
= Fget_largest_window (frames
);
2965 /* If we got a tall enough full-width window that can be split,
2968 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2969 && window_height (window
) >= split_height_threshold
2970 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
2971 window
= Fsplit_window (window
, Qnil
, Qnil
);
2974 Lisp_Object upper
, lower
, other
;
2976 window
= Fget_lru_window (frames
);
2977 /* If the LRU window is selected, and big enough,
2978 and can be split, split it. */
2980 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2981 && (EQ (window
, selected_window
)
2982 || EQ (XWINDOW (window
)->parent
, Qnil
))
2983 && window_height (window
) >= window_min_height
<< 1)
2984 window
= Fsplit_window (window
, Qnil
, Qnil
);
2985 /* If Fget_lru_window returned nil, try other approaches. */
2987 /* Try visible frames first. */
2989 window
= Fget_buffer_window (buffer
, Qvisible
);
2991 window
= Fget_largest_window (Qvisible
);
2992 /* If that didn't work, try iconified frames. */
2994 window
= Fget_buffer_window (buffer
, make_number (0));
2996 window
= Fget_largest_window (make_number (0));
2997 /* Try invisible frames. */
2999 window
= Fget_buffer_window (buffer
, Qt
);
3001 window
= Fget_largest_window (Qt
);
3002 /* As a last resort, make a new frame. */
3004 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3005 /* If window appears above or below another,
3006 even out their heights. */
3007 other
= upper
= lower
= Qnil
;
3008 if (!NILP (XWINDOW (window
)->prev
))
3009 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3010 if (!NILP (XWINDOW (window
)->next
))
3011 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3013 && !NILP (Veven_window_heights
)
3014 /* Check that OTHER and WINDOW are vertically arrayed. */
3015 && !EQ (XWINDOW (other
)->top
, XWINDOW (window
)->top
)
3016 && (XFASTINT (XWINDOW (other
)->height
)
3017 > XFASTINT (XWINDOW (window
)->height
)))
3019 int total
= (XFASTINT (XWINDOW (other
)->height
)
3020 + XFASTINT (XWINDOW (window
)->height
));
3021 enlarge_window (upper
,
3022 total
/ 2 - XFASTINT (XWINDOW (upper
)->height
),
3028 window
= Fget_lru_window (Qnil
);
3030 Fset_window_buffer (window
, buffer
);
3031 return display_buffer_1 (window
);
3035 temp_output_buffer_show (buf
)
3036 register Lisp_Object buf
;
3038 register struct buffer
*old
= current_buffer
;
3039 register Lisp_Object window
;
3040 register struct window
*w
;
3042 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3045 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3049 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3050 set_buffer_internal (old
);
3052 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3053 call1 (Vtemp_buffer_show_function
, buf
);
3056 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3058 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3059 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3060 Vminibuf_scroll_window
= window
;
3061 w
= XWINDOW (window
);
3062 XSETFASTINT (w
->hscroll
, 0);
3063 set_marker_restricted_both (w
->start
, buf
, 1, 1);
3064 set_marker_restricted_both (w
->pointm
, buf
, 1, 1);
3066 /* Run temp-buffer-show-hook, with the chosen window selected
3067 and it sbuffer current. */
3068 if (!NILP (Vrun_hooks
))
3071 tem
= Fboundp (Qtemp_buffer_show_hook
);
3074 tem
= Fsymbol_value (Qtemp_buffer_show_hook
);
3077 int count
= specpdl_ptr
- specpdl
;
3078 Lisp_Object prev_window
;
3079 prev_window
= selected_window
;
3081 /* Select the window that was chosen, for running the hook. */
3082 record_unwind_protect (Fselect_window
, prev_window
);
3083 select_window_1 (window
, 0);
3084 Fset_buffer (w
->buffer
);
3085 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3086 select_window_1 (prev_window
, 0);
3087 unbind_to (count
, Qnil
);
3095 make_dummy_parent (window
)
3099 register struct window
*o
, *p
;
3100 register struct Lisp_Vector
*vec
;
3103 o
= XWINDOW (window
);
3104 vec
= allocate_vectorlike ((EMACS_INT
)VECSIZE (struct window
));
3105 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3106 vec
->contents
[i
] = ((struct Lisp_Vector
*)o
)->contents
[i
];
3107 vec
->size
= VECSIZE (struct window
);
3108 p
= (struct window
*)vec
;
3109 XSETWINDOW (new, p
);
3111 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
3113 /* Put new into window structure in place of window */
3114 replace_window (window
, new);
3127 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3128 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
3129 WINDOW defaults to selected one and SIZE to half its size.\n\
3130 If optional third arg HORFLAG is non-nil, split side by side\n\
3131 and put SIZE columns in the first of the pair. In that case,\n\
3132 SIZE includes that window's scroll bar, or the divider column to its right.")
3133 (window
, size
, horflag
)
3134 Lisp_Object window
, size
, horflag
;
3136 register Lisp_Object
new;
3137 register struct window
*o
, *p
;
3139 register int size_int
;
3142 window
= selected_window
;
3144 CHECK_LIVE_WINDOW (window
, 0);
3146 o
= XWINDOW (window
);
3147 fo
= XFRAME (WINDOW_FRAME (o
));
3151 if (!NILP (horflag
))
3152 /* Calculate the size of the left-hand window, by dividing
3153 the usable space in columns by two.
3154 We round up, since the left-hand window may include
3155 a dividing line, while the right-hand may not. */
3156 size_int
= (XFASTINT (o
->width
) + 1) >> 1;
3158 size_int
= XFASTINT (o
->height
) >> 1;
3162 CHECK_NUMBER (size
, 1);
3163 size_int
= XINT (size
);
3166 if (MINI_WINDOW_P (o
))
3167 error ("Attempt to split minibuffer window");
3168 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3169 error ("Attempt to split fixed-size window");
3171 check_min_window_sizes ();
3175 if (size_int
< window_min_height
)
3176 error ("Window height %d too small (after splitting)", size_int
);
3177 if (size_int
+ window_min_height
> XFASTINT (o
->height
))
3178 error ("Window height %d too small (after splitting)",
3179 XFASTINT (o
->height
) - size_int
);
3180 if (NILP (o
->parent
)
3181 || NILP (XWINDOW (o
->parent
)->vchild
))
3183 make_dummy_parent (window
);
3185 XWINDOW (new)->vchild
= window
;
3190 if (size_int
< window_min_width
)
3191 error ("Window width %d too small (after splitting)", size_int
);
3193 if (size_int
+ window_min_width
> XFASTINT (o
->width
))
3194 error ("Window width %d too small (after splitting)",
3195 XFASTINT (o
->width
) - size_int
);
3196 if (NILP (o
->parent
)
3197 || NILP (XWINDOW (o
->parent
)->hchild
))
3199 make_dummy_parent (window
);
3201 XWINDOW (new)->hchild
= window
;
3205 /* Now we know that window's parent is a vertical combination
3206 if we are dividing vertically, or a horizontal combination
3207 if we are making side-by-side windows */
3209 windows_or_buffers_changed
++;
3210 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3211 new = make_window ();
3214 p
->frame
= o
->frame
;
3216 if (!NILP (p
->next
))
3217 XWINDOW (p
->next
)->prev
= new;
3220 p
->parent
= o
->parent
;
3222 p
->window_end_valid
= Qnil
;
3223 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3225 /* Apportion the available frame space among the two new windows */
3227 if (!NILP (horflag
))
3229 p
->height
= o
->height
;
3231 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size_int
);
3232 XSETFASTINT (o
->width
, size_int
);
3233 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size_int
);
3238 p
->width
= o
->width
;
3239 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size_int
);
3240 XSETFASTINT (o
->height
, size_int
);
3241 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size_int
);
3244 /* Adjust glyph matrices. */
3246 Fset_window_buffer (new, o
->buffer
);
3250 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3251 "Make current window ARG lines bigger.\n\
3252 From program, optional second arg non-nil means grow sideways ARG columns.")
3254 register Lisp_Object arg
, side
;
3256 CHECK_NUMBER (arg
, 0);
3257 enlarge_window (selected_window
, XINT (arg
), !NILP (side
));
3259 if (! NILP (Vwindow_configuration_change_hook
))
3260 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3265 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3266 "Make current window ARG lines smaller.\n\
3267 From program, optional second arg non-nil means shrink sideways arg columns.")
3269 register Lisp_Object arg
, side
;
3271 CHECK_NUMBER (arg
, 0);
3272 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3274 if (! NILP (Vwindow_configuration_change_hook
))
3275 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3281 window_height (window
)
3284 register struct window
*p
= XWINDOW (window
);
3285 return XFASTINT (p
->height
);
3289 window_width (window
)
3292 register struct window
*p
= XWINDOW (window
);
3293 return XFASTINT (p
->width
);
3298 *(widthflag ? &(XWINDOW (w)->left) : &(XWINDOW (w)->top))
3300 #define CURSIZE(w) \
3301 *(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
3304 /* Enlarge selected_window by DELTA. WIDTHFLAG non-zero means
3305 increase its width. Siblings of the selected window are resized to
3306 fullfil the size request. If they become too small in the process,
3307 they will be deleted. */
3310 enlarge_window (window
, delta
, widthflag
)
3312 int delta
, widthflag
;
3314 Lisp_Object parent
, next
, prev
;
3318 int (*sizefun
) P_ ((Lisp_Object
))
3319 = widthflag
? window_width
: window_height
;
3320 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3321 = (widthflag
? set_window_width
: set_window_height
);
3323 /* Check values of window_min_width and window_min_height for
3325 check_min_window_sizes ();
3327 /* Give up if this window cannot be resized. */
3328 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3329 error ("Window is not resizable");
3331 /* Find the parent of the selected window. */
3334 p
= XWINDOW (window
);
3340 error ("No other window to side of this one");
3345 ? !NILP (XWINDOW (parent
)->hchild
)
3346 : !NILP (XWINDOW (parent
)->vchild
))
3352 sizep
= &CURSIZE (window
);
3355 register int maxdelta
;
3357 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3358 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3359 - window_min_size (XWINDOW (p
->next
),
3361 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3362 - window_min_size (XWINDOW (p
->prev
),
3364 /* This is a frame with only one window, a minibuffer-only
3365 or a minibufferless frame. */
3368 if (delta
> maxdelta
)
3369 /* This case traps trying to make the minibuffer
3370 the full frame, or make the only window aside from the
3371 minibuffer the full frame. */
3375 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3377 delete_window (window
);
3384 /* Find the total we can get from other siblings. */
3386 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3387 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3389 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3390 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3393 /* If we can get it all from them, do so. */
3394 if (delta
<= maximum
)
3396 Lisp_Object first_unaffected
;
3397 Lisp_Object first_affected
;
3402 first_affected
= window
;
3403 /* Look at one sibling at a time,
3404 moving away from this window in both directions alternately,
3405 and take as much as we can get without deleting that sibling. */
3406 while (delta
!= 0 && (!NILP (next
) || !NILP (prev
)))
3410 int this_one
= ((*sizefun
) (next
)
3411 - window_min_size (XWINDOW (next
),
3412 widthflag
, 0, &fixed_p
));
3415 if (this_one
> delta
)
3418 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
3419 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3424 next
= XWINDOW (next
)->next
;
3432 int this_one
= ((*sizefun
) (prev
)
3433 - window_min_size (XWINDOW (prev
),
3434 widthflag
, 0, &fixed_p
));
3437 if (this_one
> delta
)
3440 first_affected
= prev
;
3442 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
3443 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3448 prev
= XWINDOW (prev
)->prev
;
3452 xassert (delta
== 0);
3454 /* Now recalculate the edge positions of all the windows affected,
3455 based on the new sizes. */
3456 first_unaffected
= next
;
3457 prev
= first_affected
;
3458 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
3459 prev
= next
, next
= XWINDOW (next
)->next
)
3461 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
3462 /* This does not change size of NEXT,
3463 but it propagates the new top edge to its children */
3464 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
3469 register int delta1
;
3470 register int opht
= (*sizefun
) (parent
);
3472 /* If trying to grow this window to or beyond size of the parent,
3473 make delta1 so big that, on shrinking back down,
3474 all the siblings end up with less than one line and are deleted. */
3475 if (opht
<= XINT (*sizep
) + delta
)
3476 delta1
= opht
* opht
* 2;
3479 /* Otherwise, make delta1 just right so that if we add
3480 delta1 lines to this window and to the parent, and then
3481 shrink the parent back to its original size, the new
3482 proportional size of this window will increase by delta.
3484 The function size_window will compute the new height h'
3485 of the window from delta1 as:
3488 x = delta1 - delta1/n * n for the 1st resizable child
3491 where n is the number of children that can be resized.
3492 We can ignore x by choosing a delta1 that is a multiple of
3493 n. We want the height of this window to come out as
3503 The number of children n rquals the number of resizable
3504 children of this window + 1 because we know window itself
3505 is resizable (otherwise we would have signalled an error. */
3507 struct window
*w
= XWINDOW (window
);
3511 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
3512 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
3514 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
3515 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
3521 /* Add delta1 lines or columns to this window, and to the parent,
3522 keeping things consistent while not affecting siblings. */
3523 XSETINT (CURSIZE (parent
), opht
+ delta1
);
3524 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
3526 /* Squeeze out delta1 lines or columns from our parent,
3527 shriking this window and siblings proportionately.
3528 This brings parent back to correct size.
3529 Delta1 was calculated so this makes this window the desired size,
3530 taking it all out of the siblings. */
3531 (*setsizefun
) (parent
, opht
, 0);
3534 XSETFASTINT (p
->last_modified
, 0);
3535 XSETFASTINT (p
->last_overlay_modified
, 0);
3537 /* Adjust glyph matrices. */
3538 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
3546 /***********************************************************************
3547 Resizing Mini-Windows
3548 ***********************************************************************/
3550 static void shrink_window_lowest_first
P_ ((struct window
*, int));
3552 enum save_restore_action
3559 static int save_restore_orig_size
P_ ((struct window
*,
3560 enum save_restore_action
));
3562 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
3563 from lowest windows first. */
3566 shrink_window_lowest_first (w
, height
)
3574 xassert (!MINI_WINDOW_P (w
));
3576 /* Set redisplay hints. */
3577 XSETFASTINT (w
->last_modified
, 0);
3578 XSETFASTINT (w
->last_overlay_modified
, 0);
3579 windows_or_buffers_changed
++;
3580 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
3582 old_height
= XFASTINT (w
->height
);
3583 XSETFASTINT (w
->height
, height
);
3585 if (!NILP (w
->hchild
))
3587 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
3589 c
= XWINDOW (child
);
3591 shrink_window_lowest_first (c
, height
);
3594 else if (!NILP (w
->vchild
))
3596 Lisp_Object last_child
;
3597 int delta
= old_height
- height
;
3602 /* Find the last child. We are taking space from lowest windows
3603 first, so we iterate over children from the last child
3605 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
3608 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
3609 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
3613 c
= XWINDOW (child
);
3614 this_one
= XFASTINT (c
->height
) - MIN_SAFE_WINDOW_HEIGHT
;
3616 if (this_one
> delta
)
3619 shrink_window_lowest_first (c
, XFASTINT (c
->height
) - this_one
);
3623 /* Compute new positions. */
3624 last_top
= XINT (w
->top
);
3625 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
3627 c
= XWINDOW (child
);
3628 c
->top
= make_number (last_top
);
3629 shrink_window_lowest_first (c
, XFASTINT (c
->height
));
3630 last_top
+= XFASTINT (c
->height
);
3636 /* Save, restore, or check positions and sizes in the window tree
3637 rooted at W. ACTION says what to do.
3639 If ACTION is CHECK_ORIG_SIZES, check if orig_top and orig_height
3640 members are valid for all windows in the window tree. Value is
3641 non-zero if they are valid.
3643 If ACTION is SAVE_ORIG_SIZES, save members top and height in
3644 orig_top and orig_height for all windows in the tree.
3646 If ACTION is RESTORE_ORIG_SIZES, restore top and height from
3647 values stored in orig_top and orig_height for all windows. */
3650 save_restore_orig_size (w
, action
)
3652 enum save_restore_action action
;
3658 if (!NILP (w
->hchild
))
3660 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
3663 else if (!NILP (w
->vchild
))
3665 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
3671 case CHECK_ORIG_SIZES
:
3672 if (!INTEGERP (w
->orig_top
) || !INTEGERP (w
->orig_height
))
3676 case SAVE_ORIG_SIZES
:
3677 w
->orig_top
= w
->top
;
3678 w
->orig_height
= w
->height
;
3679 XSETFASTINT (w
->last_modified
, 0);
3680 XSETFASTINT (w
->last_overlay_modified
, 0);
3683 case RESTORE_ORIG_SIZES
:
3684 xassert (INTEGERP (w
->orig_top
) && INTEGERP (w
->orig_height
));
3685 w
->top
= w
->orig_top
;
3686 w
->height
= w
->orig_height
;
3687 w
->orig_height
= w
->orig_top
= Qnil
;
3688 XSETFASTINT (w
->last_modified
, 0);
3689 XSETFASTINT (w
->last_overlay_modified
, 0);
3696 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
3703 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
3704 without deleting other windows. */
3707 grow_mini_window (w
, delta
)
3711 struct frame
*f
= XFRAME (w
->frame
);
3712 struct window
*root
;
3714 xassert (MINI_WINDOW_P (w
));
3715 xassert (delta
>= 0);
3717 /* Check values of window_min_width and window_min_height for
3719 check_min_window_sizes ();
3721 /* Compute how much we can enlarge the mini-window without deleting
3723 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3726 int min_height
= window_min_size (root
, 0, 0, 0);
3727 if (XFASTINT (root
->height
) - delta
< min_height
)
3728 delta
= XFASTINT (root
->height
) - min_height
;
3733 /* Save original window sizes and positions, if not already done. */
3734 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
3735 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
3737 /* Shrink other windows. */
3738 shrink_window_lowest_first (root
, XFASTINT (root
->height
) - delta
);
3740 /* Grow the mini-window. */
3741 w
->top
= make_number (XFASTINT (root
->top
) + XFASTINT (root
->height
));
3742 w
->height
= make_number (XFASTINT (w
->height
) + delta
);
3743 XSETFASTINT (w
->last_modified
, 0);
3744 XSETFASTINT (w
->last_overlay_modified
, 0);
3751 /* Shrink mini-window W. If there is recorded info about window sizes
3752 before a call to grow_mini_window, restore recorded window sizes.
3753 Otherwise, if the mini-window is higher than 1 line, resize it to 1
3757 shrink_mini_window (w
)
3760 struct frame
*f
= XFRAME (w
->frame
);
3761 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3763 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
3765 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
3767 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3768 windows_or_buffers_changed
= 1;
3770 else if (XFASTINT (w
->height
) > 1)
3773 XSETWINDOW (window
, w
);
3774 enlarge_window (window
, 1 - XFASTINT (w
->height
), 0);
3780 /* Mark window cursors off for all windows in the window tree rooted
3781 at W by setting their phys_cursor_on_p flag to zero. Called from
3782 xterm.c, e.g. when a frame is cleared and thereby all cursors on
3783 the frame are cleared. */
3786 mark_window_cursors_off (w
)
3791 if (!NILP (w
->hchild
))
3792 mark_window_cursors_off (XWINDOW (w
->hchild
));
3793 else if (!NILP (w
->vchild
))
3794 mark_window_cursors_off (XWINDOW (w
->vchild
));
3796 w
->phys_cursor_on_p
= 0;
3798 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3803 /* Return number of lines of text (not counting mode line) in W. */
3806 window_internal_height (w
)
3809 int ht
= XFASTINT (w
->height
);
3811 if (MINI_WINDOW_P (w
))
3814 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
3815 || !NILP (w
->next
) || !NILP (w
->prev
)
3816 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
3823 /* Return the number of columns in W.
3824 Don't count columns occupied by scroll bars or the vertical bar
3825 separating W from the sibling to its right. */
3828 window_internal_width (w
)
3831 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3832 int width
= XINT (w
->width
);
3834 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3835 /* Scroll bars occupy a few columns. */
3836 width
-= FRAME_SCROLL_BAR_COLS (f
);
3837 else if (!WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
3838 /* The column of `|' characters separating side-by-side windows
3839 occupies one column only. */
3842 /* On window-systems, areas to the left and right of the window
3843 are used to display bitmaps there. */
3844 if (FRAME_WINDOW_P (f
))
3845 width
-= FRAME_FLAGS_AREA_COLS (f
);
3851 /************************************************************************
3853 ***********************************************************************/
3855 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
3856 one screen-full, which is defined as the height of the window minus
3857 next_screen_context_lines. If WHOLE is zero, scroll up N lines
3858 instead. Negative values of N mean scroll down. NOERROR non-zero
3859 means don't signal an error if we try to move over BEGV or ZV,
3863 window_scroll (window
, n
, whole
, noerror
)
3869 /* If we must, use the pixel-based version which is much slower than
3870 the line-based one but can handle varying line heights. */
3871 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
3872 window_scroll_pixel_based (window
, n
, whole
, noerror
);
3874 window_scroll_line_based (window
, n
, whole
, noerror
);
3878 /* Implementation of window_scroll that works based on pixel line
3879 heights. See the comment of window_scroll for parameter
3883 window_scroll_pixel_based (window
, n
, whole
, noerror
)
3890 struct window
*w
= XWINDOW (window
);
3891 struct text_pos start
;
3893 int this_scroll_margin
;
3895 /* True if we fiddled the window vscroll field without really scrolling. */
3898 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
3900 /* If PT is not visible in WINDOW, move back one half of
3902 XSETFASTINT (tem
, PT
);
3903 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
3906 /* Move backward half the height of the window. Performance note:
3907 vmotion used here is about 10% faster, but would give wrong
3908 results for variable height lines. */
3909 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
3910 it
.current_y
= it
.last_visible_y
;
3911 move_it_vertically (&it
, -it
.last_visible_y
/ 2);
3913 /* The function move_iterator_vertically may move over more than
3914 the specified y-distance. If it->w is small, e.g. a
3915 mini-buffer window, we may end up in front of the window's
3916 display area. This is the case when Start displaying at the
3917 start of the line containing PT in this case. */
3918 if (it
.current_y
<= 0)
3920 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
3921 move_it_vertically (&it
, 0);
3925 start
= it
.current
.pos
;
3928 /* If scroll_preserve_screen_position is non-zero, we try to set
3929 point in the same window line as it is now, so get that line. */
3930 if (!NILP (Vscroll_preserve_screen_position
))
3932 start_display (&it
, w
, start
);
3933 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
3934 preserve_y
= it
.current_y
;
3939 /* Move iterator it from start the specified distance forward or
3940 backward. The result is the new window start. */
3941 start_display (&it
, w
, start
);
3944 int screen_full
= (it
.last_visible_y
3945 - next_screen_context_lines
* CANON_Y_UNIT (it
.f
));
3946 int direction
= n
< 0 ? -1 : 1;
3947 move_it_vertically (&it
, direction
* screen_full
);
3950 move_it_by_lines (&it
, n
, 1);
3952 /* End if we end up at ZV or BEGV. */
3953 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
3954 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
3956 if (IT_CHARPOS (it
) == ZV
)
3958 if (it
.current_y
+ it
.max_ascent
+ it
.max_descent
3959 > it
.last_visible_y
)
3960 /* The last line was only partially visible, make it fully
3964 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
3968 Fsignal (Qend_of_buffer
, Qnil
);
3972 if (w
->vscroll
!= 0)
3973 /* The first line was only partially visible, make it fully
3979 Fsignal (Qbeginning_of_buffer
, Qnil
);
3982 /* If control gets here, then we vscrolled. */
3984 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3986 /* Don't try to change the window start below. */
3992 /* Set the window start, and set up the window for redisplay. */
3993 set_marker_restricted (w
->start
, make_number (IT_CHARPOS (it
)),
3995 w
->start_at_line_beg
= Fbolp ();
3996 w
->update_mode_line
= Qt
;
3997 XSETFASTINT (w
->last_modified
, 0);
3998 XSETFASTINT (w
->last_overlay_modified
, 0);
3999 /* Set force_start so that redisplay_window will run the
4000 window-scroll-functions. */
4001 w
->force_start
= Qt
;
4004 it
.current_y
= it
.vpos
= 0;
4006 /* Preserve the screen position if we must. */
4007 if (preserve_y
>= 0)
4009 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4010 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4014 /* Move PT out of scroll margins. */
4015 this_scroll_margin
= max (0, scroll_margin
);
4016 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->height
) / 4);
4017 this_scroll_margin
*= CANON_Y_UNIT (it
.f
);
4021 /* We moved the window start towards ZV, so PT may be now
4022 in the scroll margin at the top. */
4023 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4024 while (it
.current_y
< this_scroll_margin
)
4025 move_it_by_lines (&it
, 1, 1);
4026 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4030 int charpos
, bytepos
;
4032 /* We moved the window start towards BEGV, so PT may be now
4033 in the scroll margin at the bottom. */
4034 move_it_to (&it
, PT
, -1,
4035 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4036 MOVE_TO_POS
| MOVE_TO_Y
);
4038 /* Save our position, in case it's correct. */
4039 charpos
= IT_CHARPOS (it
);
4040 bytepos
= IT_BYTEPOS (it
);
4042 /* See if point is on a partially visible line at the end. */
4043 move_it_by_lines (&it
, 1, 1);
4044 if (it
.current_y
> it
.last_visible_y
)
4045 /* The last line was only partially visible, so back up two
4046 lines to make sure we're on a fully visible line. */
4048 move_it_by_lines (&it
, -2, 0);
4049 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4052 /* No, the position we saved is OK, so use it. */
4053 SET_PT_BOTH (charpos
, bytepos
);
4059 /* Implementation of window_scroll that works based on screen lines.
4060 See the comment of window_scroll for parameter descriptions. */
4063 window_scroll_line_based (window
, n
, whole
, noerror
)
4069 register struct window
*w
= XWINDOW (window
);
4070 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4071 register int pos
, pos_byte
;
4072 register int ht
= window_internal_height (w
);
4073 register Lisp_Object tem
;
4077 struct position posit
;
4080 startpos
= marker_position (w
->start
);
4082 posit
= *compute_motion (startpos
, 0, 0, 0,
4084 window_internal_width (w
), XINT (w
->hscroll
),
4086 original_vpos
= posit
.vpos
;
4088 XSETFASTINT (tem
, PT
);
4089 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4093 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4098 lose
= n
< 0 && PT
== BEGV
;
4099 Fvertical_motion (make_number (n
), window
);
4103 SET_PT_BOTH (opoint
, opoint_byte
);
4110 Fsignal (Qbeginning_of_buffer
, Qnil
);
4115 int this_scroll_margin
= scroll_margin
;
4117 /* Don't use a scroll margin that is negative or too large. */
4118 if (this_scroll_margin
< 0)
4119 this_scroll_margin
= 0;
4121 if (XINT (w
->height
) < 4 * scroll_margin
)
4122 this_scroll_margin
= XINT (w
->height
) / 4;
4124 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4125 w
->start_at_line_beg
= bolp
;
4126 w
->update_mode_line
= Qt
;
4127 XSETFASTINT (w
->last_modified
, 0);
4128 XSETFASTINT (w
->last_overlay_modified
, 0);
4129 /* Set force_start so that redisplay_window will run
4130 the window-scroll-functions. */
4131 w
->force_start
= Qt
;
4133 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4135 SET_PT_BOTH (pos
, pos_byte
);
4136 Fvertical_motion (make_number (original_vpos
), window
);
4138 /* If we scrolled forward, put point enough lines down
4139 that it is outside the scroll margin. */
4144 if (this_scroll_margin
> 0)
4146 SET_PT_BOTH (pos
, pos_byte
);
4147 Fvertical_motion (make_number (this_scroll_margin
), window
);
4153 if (top_margin
<= opoint
)
4154 SET_PT_BOTH (opoint
, opoint_byte
);
4155 else if (!NILP (Vscroll_preserve_screen_position
))
4157 SET_PT_BOTH (pos
, pos_byte
);
4158 Fvertical_motion (make_number (original_vpos
), window
);
4161 SET_PT (top_margin
);
4167 /* If we scrolled backward, put point near the end of the window
4168 but not within the scroll margin. */
4169 SET_PT_BOTH (pos
, pos_byte
);
4170 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4171 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4174 bottom_margin
= PT
+ 1;
4176 if (bottom_margin
> opoint
)
4177 SET_PT_BOTH (opoint
, opoint_byte
);
4180 if (!NILP (Vscroll_preserve_screen_position
))
4182 SET_PT_BOTH (pos
, pos_byte
);
4183 Fvertical_motion (make_number (original_vpos
), window
);
4186 Fvertical_motion (make_number (-1), window
);
4195 Fsignal (Qend_of_buffer
, Qnil
);
4200 /* Scroll selected_window up or down. If N is nil, scroll a
4201 screen-full which is defined as the height of the window minus
4202 next_screen_context_lines. If N is the symbol `-', scroll.
4203 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4204 up. This is the guts of Fscroll_up and Fscroll_down. */
4207 scroll_command (n
, direction
)
4211 register int defalt
;
4212 int count
= specpdl_ptr
- specpdl
;
4214 xassert (abs (direction
) == 1);
4216 /* If selected window's buffer isn't current, make it current for
4217 the moment. But don't screw up if window_scroll gets an error. */
4218 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4220 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4221 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4223 /* Make redisplay consider other windows than just selected_window. */
4224 ++windows_or_buffers_changed
;
4227 defalt
= (window_internal_height (XWINDOW (selected_window
))
4228 - next_screen_context_lines
);
4229 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
4232 window_scroll (selected_window
, defalt
, 1, 0);
4233 else if (EQ (n
, Qminus
))
4234 window_scroll (selected_window
, - defalt
, 1, 0);
4237 n
= Fprefix_numeric_value (n
);
4238 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4241 unbind_to (count
, Qnil
);
4244 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
4245 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
4246 A near full screen is `next-screen-context-lines' less than a full screen.\n\
4247 Negative ARG means scroll downward.\n\
4248 If ARG is the atom `-', scroll downward by nearly full screen.\n\
4249 When calling from a program, supply as argument a number, nil, or `-'.")
4253 scroll_command (arg
, 1);
4257 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
4258 "Scroll text of current window down ARG lines; or near full screen if no ARG.\n\
4259 A near full screen is `next-screen-context-lines' less than a full screen.\n\
4260 Negative ARG means scroll upward.\n\
4261 If ARG is the atom `-', scroll upward by nearly full screen.\n\
4262 When calling from a program, supply as argument a number, nil, or `-'.")
4266 scroll_command (arg
, -1);
4270 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4271 "Return the other window for \"other window scroll\" commands.\n\
4272 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
4273 specifies the window.\n\
4274 If `other-window-scroll-buffer' is non-nil, a window\n\
4275 showing that buffer is used.")
4280 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4281 && !NILP (Vminibuf_scroll_window
))
4282 window
= Vminibuf_scroll_window
;
4283 /* If buffer is specified, scroll that buffer. */
4284 else if (!NILP (Vother_window_scroll_buffer
))
4286 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4288 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4292 /* Nothing specified; look for a neighboring window on the same
4294 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4296 if (EQ (window
, selected_window
))
4297 /* That didn't get us anywhere; look for a window on another
4300 window
= Fnext_window (window
, Qnil
, Qt
);
4301 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4302 && ! EQ (window
, selected_window
));
4305 CHECK_LIVE_WINDOW (window
, 0);
4307 if (EQ (window
, selected_window
))
4308 error ("There is no other window");
4313 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4314 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
4315 A near full screen is `next-screen-context-lines' less than a full screen.\n\
4316 The next window is the one below the current one; or the one at the top\n\
4317 if the current one is at the bottom. Negative ARG means scroll downward.\n\
4318 If ARG is the atom `-', scroll downward by nearly full screen.\n\
4319 When calling from a program, supply as argument a number, nil, or `-'.\n\
4321 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
4322 specifies the window to scroll.\n\
4323 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
4324 showing that buffer, popping the buffer up if necessary.")
4326 register Lisp_Object arg
;
4328 register Lisp_Object window
;
4329 register int defalt
;
4330 register struct window
*w
;
4331 register int count
= specpdl_ptr
- specpdl
;
4333 window
= Fother_window_for_scrolling ();
4335 w
= XWINDOW (window
);
4336 defalt
= window_internal_height (w
) - next_screen_context_lines
;
4337 if (defalt
< 1) defalt
= 1;
4339 /* Don't screw up if window_scroll gets an error. */
4340 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4341 ++windows_or_buffers_changed
;
4343 Fset_buffer (w
->buffer
);
4344 SET_PT (marker_position (w
->pointm
));
4347 window_scroll (window
, defalt
, 1, 1);
4348 else if (EQ (arg
, Qminus
))
4349 window_scroll (window
, -defalt
, 1, 1);
4354 CHECK_NUMBER (arg
, 0);
4355 window_scroll (window
, XINT (arg
), 0, 1);
4358 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4359 unbind_to (count
, Qnil
);
4364 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
4365 "Scroll selected window display ARG columns left.\n\
4366 Default for ARG is window width minus 2.")
4368 register Lisp_Object arg
;
4372 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
4374 arg
= Fprefix_numeric_value (arg
);
4377 Fset_window_hscroll (selected_window
,
4378 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
4382 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
4383 "Scroll selected window display ARG columns right.\n\
4384 Default for ARG is window width minus 2.")
4386 register Lisp_Object arg
;
4389 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
4391 arg
= Fprefix_numeric_value (arg
);
4394 Fset_window_hscroll (selected_window
,
4395 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
4399 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
4400 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
4401 The desired position of point is always relative to the current window.\n\
4402 Just C-u as prefix means put point in the center of the window.\n\
4403 If ARG is omitted or nil, erases the entire frame and then\n\
4404 redraws with point in the center of the current window.")
4406 register Lisp_Object arg
;
4408 register struct window
*w
= XWINDOW (selected_window
);
4409 register int ht
= window_internal_height (w
);
4410 struct position pos
;
4411 struct buffer
*buf
= XBUFFER (w
->buffer
);
4412 struct buffer
*obuf
= current_buffer
;
4416 extern int frame_garbaged
;
4419 /* Invalidate pixel data calculated for all compositions. */
4420 for (i
= 0; i
< n_compositions
; i
++)
4421 composition_table
[i
]->font
= NULL
;
4423 Fredraw_frame (w
->frame
);
4424 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
4425 XSETFASTINT (arg
, ht
/ 2);
4427 else if (CONSP (arg
)) /* Just C-u. */
4429 XSETFASTINT (arg
, ht
/ 2);
4433 arg
= Fprefix_numeric_value (arg
);
4434 CHECK_NUMBER (arg
, 0);
4438 XSETINT (arg
, XINT (arg
) + ht
);
4440 set_buffer_internal (buf
);
4441 pos
= *vmotion (PT
, - XINT (arg
), w
);
4443 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
4444 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
4445 || FETCH_BYTE (pos
.bytepos
- 1) == '\n')
4447 w
->force_start
= Qt
;
4448 set_buffer_internal (obuf
);
4454 /* Value is the number of lines actually displayed in window W,
4455 as opposed to its height. */
4458 displayed_window_lines (w
)
4462 struct text_pos start
;
4463 int height
= window_box_height (w
);
4464 struct buffer
*old_buffer
;
4467 if (XBUFFER (w
->buffer
) != current_buffer
)
4469 old_buffer
= current_buffer
;
4470 set_buffer_internal (XBUFFER (w
->buffer
));
4475 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4476 start_display (&it
, w
, start
);
4477 move_it_vertically (&it
, height
);
4480 set_buffer_internal (old_buffer
);
4482 bottom_y
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
4484 if (bottom_y
> it
.current_y
&& bottom_y
<= it
.last_visible_y
)
4485 /* Hit a line without a terminating newline. */
4488 /* Add in empty lines at the bottom of the window. */
4489 if (bottom_y
< height
)
4491 struct frame
*f
= XFRAME (w
->frame
);
4492 int rest
= height
- bottom_y
;
4493 int lines
= rest
/ CANON_Y_UNIT (f
);
4501 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
4503 "Return the height in lines of the text display area of WINDOW.\n\
4504 This doesn't include the mode-line (or header-line if any) or any\n\
4505 partial-height lines in the text display area.")
4509 struct window
*w
= decode_window (window
);
4510 int pixel_height
= window_box_height (w
);
4511 int line_height
= pixel_height
/ CANON_Y_UNIT (XFRAME (w
->frame
));
4512 return make_number (line_height
);
4517 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
4519 "Position point relative to window.\n\
4520 With no argument, position point at center of window.\n\
4521 An argument specifies vertical position within the window;\n\
4522 zero means top of window, negative means relative to bottom of window.")
4526 struct window
*w
= XWINDOW (selected_window
);
4530 window
= selected_window
;
4531 start
= marker_position (w
->start
);
4532 if (start
< BEGV
|| start
> ZV
)
4534 int height
= window_internal_height (w
);
4535 Fvertical_motion (make_number (- (height
/ 2)), window
);
4536 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
4537 w
->start_at_line_beg
= Fbolp ();
4538 w
->force_start
= Qt
;
4541 Fgoto_char (w
->start
);
4543 lines
= displayed_window_lines (w
);
4545 XSETFASTINT (arg
, lines
/ 2);
4548 arg
= Fprefix_numeric_value (arg
);
4550 XSETINT (arg
, XINT (arg
) + lines
);
4554 /* Skip past a partially visible first line. */
4555 XSETINT (arg
, XINT (arg
) + 1);
4557 return Fvertical_motion (arg
, window
);
4562 /***********************************************************************
4563 Window Configuration
4564 ***********************************************************************/
4566 struct save_window_data
4568 EMACS_INT size_from_Lisp_Vector_struct
;
4569 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
4570 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
4571 Lisp_Object frame_tool_bar_lines
;
4572 Lisp_Object selected_frame
;
4573 Lisp_Object current_window
;
4574 Lisp_Object current_buffer
;
4575 Lisp_Object minibuf_scroll_window
;
4576 Lisp_Object root_window
;
4577 Lisp_Object focus_frame
;
4578 /* Record the values of window-min-width and window-min-height
4579 so that window sizes remain consistent with them. */
4580 Lisp_Object min_width
, min_height
;
4581 /* A vector, each of whose elements is a struct saved_window
4583 Lisp_Object saved_windows
;
4586 /* This is saved as a Lisp_Vector */
4589 /* these first two must agree with struct Lisp_Vector in lisp.h */
4590 EMACS_INT size_from_Lisp_Vector_struct
;
4591 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
4594 Lisp_Object buffer
, start
, pointm
, mark
;
4595 Lisp_Object left
, top
, width
, height
, hscroll
;
4596 Lisp_Object parent
, prev
;
4597 Lisp_Object start_at_line_beg
;
4598 Lisp_Object display_table
;
4599 Lisp_Object orig_top
, orig_height
;
4601 #define SAVED_WINDOW_VECTOR_SIZE 16 /* Arg to Fmake_vector */
4603 #define SAVED_WINDOW_N(swv,n) \
4604 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
4606 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
4607 "Return t if OBJECT is a window-configuration object.")
4611 if (WINDOW_CONFIGURATIONP (object
))
4616 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
4617 "Return the frame that CONFIG, a window-configuration object, is about.")
4621 register struct save_window_data
*data
;
4622 struct Lisp_Vector
*saved_windows
;
4624 if (! WINDOW_CONFIGURATIONP (config
))
4625 wrong_type_argument (Qwindow_configuration_p
, config
);
4627 data
= (struct save_window_data
*) XVECTOR (config
);
4628 saved_windows
= XVECTOR (data
->saved_windows
);
4629 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
4632 DEFUN ("set-window-configuration", Fset_window_configuration
,
4633 Sset_window_configuration
, 1, 1, 0,
4634 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
4635 CONFIGURATION must be a value previously returned\n\
4636 by `current-window-configuration' (which see).\n\
4637 If CONFIGURATION was made from a frame that is now deleted,\n\
4638 only frame-independent values can be restored. In this case,\n\
4639 the return value is nil. Otherwise the value is t.")
4641 Lisp_Object configuration
;
4643 register struct save_window_data
*data
;
4644 struct Lisp_Vector
*saved_windows
;
4645 Lisp_Object new_current_buffer
;
4650 while (!WINDOW_CONFIGURATIONP (configuration
))
4651 wrong_type_argument (Qwindow_configuration_p
, configuration
);
4653 data
= (struct save_window_data
*) XVECTOR (configuration
);
4654 saved_windows
= XVECTOR (data
->saved_windows
);
4656 new_current_buffer
= data
->current_buffer
;
4657 if (NILP (XBUFFER (new_current_buffer
)->name
))
4658 new_current_buffer
= Qnil
;
4661 if (XBUFFER (new_current_buffer
) == current_buffer
)
4665 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
4668 /* If f is a dead frame, don't bother rebuilding its window tree.
4669 However, there is other stuff we should still try to do below. */
4670 if (FRAME_LIVE_P (f
))
4672 register struct window
*w
;
4673 register struct saved_window
*p
;
4674 struct window
*root_window
;
4675 struct window
**leaf_windows
;
4679 /* If the frame has been resized since this window configuration was
4680 made, we change the frame to the size specified in the
4681 configuration, restore the configuration, and then resize it
4682 back. We keep track of the prevailing height in these variables. */
4683 int previous_frame_height
= FRAME_HEIGHT (f
);
4684 int previous_frame_width
= FRAME_WIDTH (f
);
4685 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
4686 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
4688 /* The mouse highlighting code could get screwed up
4689 if it runs during this. */
4692 if (XFASTINT (data
->frame_height
) != previous_frame_height
4693 || XFASTINT (data
->frame_width
) != previous_frame_width
)
4694 change_frame_size (f
, XFASTINT (data
->frame_height
),
4695 XFASTINT (data
->frame_width
), 0, 0, 0);
4696 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
4697 if (XFASTINT (data
->frame_menu_bar_lines
)
4698 != previous_frame_menu_bar_lines
)
4699 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
4700 #ifdef HAVE_WINDOW_SYSTEM
4701 if (XFASTINT (data
->frame_tool_bar_lines
)
4702 != previous_frame_tool_bar_lines
)
4703 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
4707 /* "Swap out" point from the selected window
4708 into its buffer. We do this now, before
4709 restoring the window contents, and prevent it from
4710 being done later on when we select a new window. */
4711 if (! NILP (XWINDOW (selected_window
)->buffer
))
4713 w
= XWINDOW (selected_window
);
4714 set_marker_both (w
->pointm
,
4716 BUF_PT (XBUFFER (w
->buffer
)),
4717 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
4720 windows_or_buffers_changed
++;
4721 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4723 /* Problem: Freeing all matrices and later allocating them again
4724 is a serious redisplay flickering problem. What we would
4725 really like to do is to free only those matrices not reused
4727 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4729 = (struct window
**) alloca (count_windows (root_window
)
4730 * sizeof (struct window
*));
4731 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
4733 /* Temporarily avoid any problems with windows that are smaller
4734 than they are supposed to be. */
4735 window_min_height
= 1;
4736 window_min_width
= 1;
4739 Mark all windows now on frame as "deleted".
4740 Restoring the new configuration "undeletes" any that are in it.
4742 Save their current buffers in their height fields, since we may
4743 need it later, if a buffer saved in the configuration is now
4745 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
4747 for (k
= 0; k
< saved_windows
->size
; k
++)
4749 p
= SAVED_WINDOW_N (saved_windows
, k
);
4750 w
= XWINDOW (p
->window
);
4753 if (!NILP (p
->parent
))
4754 w
->parent
= SAVED_WINDOW_N (saved_windows
,
4755 XFASTINT (p
->parent
))->window
;
4759 if (!NILP (p
->prev
))
4761 w
->prev
= SAVED_WINDOW_N (saved_windows
,
4762 XFASTINT (p
->prev
))->window
;
4763 XWINDOW (w
->prev
)->next
= p
->window
;
4768 if (!NILP (w
->parent
))
4770 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
4772 XWINDOW (w
->parent
)->vchild
= p
->window
;
4773 XWINDOW (w
->parent
)->hchild
= Qnil
;
4777 XWINDOW (w
->parent
)->hchild
= p
->window
;
4778 XWINDOW (w
->parent
)->vchild
= Qnil
;
4783 /* If we squirreled away the buffer in the window's height,
4785 if (BUFFERP (w
->height
))
4786 w
->buffer
= w
->height
;
4789 w
->width
= p
->width
;
4790 w
->height
= p
->height
;
4791 w
->hscroll
= p
->hscroll
;
4792 w
->display_table
= p
->display_table
;
4793 w
->orig_top
= p
->orig_top
;
4794 w
->orig_height
= p
->orig_height
;
4795 XSETFASTINT (w
->last_modified
, 0);
4796 XSETFASTINT (w
->last_overlay_modified
, 0);
4798 /* Reinstall the saved buffer and pointers into it. */
4799 if (NILP (p
->buffer
))
4800 w
->buffer
= p
->buffer
;
4803 if (!NILP (XBUFFER (p
->buffer
)->name
))
4804 /* If saved buffer is alive, install it. */
4806 w
->buffer
= p
->buffer
;
4807 w
->start_at_line_beg
= p
->start_at_line_beg
;
4808 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
4809 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
4810 Fset_marker (XBUFFER (w
->buffer
)->mark
,
4811 p
->mark
, w
->buffer
);
4813 /* As documented in Fcurrent_window_configuration, don't
4814 save the location of point in the buffer which was current
4815 when the window configuration was recorded. */
4816 if (!EQ (p
->buffer
, new_current_buffer
)
4817 && XBUFFER (p
->buffer
) == current_buffer
)
4818 Fgoto_char (w
->pointm
);
4820 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
4821 /* Else unless window has a live buffer, get one. */
4823 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
4824 /* This will set the markers to beginning of visible
4826 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
4827 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
4828 w
->start_at_line_beg
= Qt
;
4831 /* Keeping window's old buffer; make sure the markers
4834 /* Set window markers at start of visible range. */
4835 if (XMARKER (w
->start
)->buffer
== 0)
4836 set_marker_restricted (w
->start
, make_number (0),
4838 if (XMARKER (w
->pointm
)->buffer
== 0)
4839 set_marker_restricted_both (w
->pointm
, w
->buffer
,
4840 BUF_PT (XBUFFER (w
->buffer
)),
4841 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
4842 w
->start_at_line_beg
= Qt
;
4847 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
4848 /* Prevent "swapping out point" in the old selected window
4849 using the buffer that has been restored into it.
4850 That swapping out has already been done,
4851 near the beginning of this function. */
4852 selected_window
= Qnil
;
4853 Fselect_window (data
->current_window
);
4854 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
4857 if (NILP (data
->focus_frame
)
4858 || (FRAMEP (data
->focus_frame
)
4859 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
4860 Fredirect_frame_focus (frame
, data
->focus_frame
);
4862 #if 0 /* I don't understand why this is needed, and it causes problems
4863 when the frame's old selected window has been deleted. */
4864 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
4865 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
4869 /* Set the screen height to the value it had before this function. */
4870 if (previous_frame_height
!= FRAME_HEIGHT (f
)
4871 || previous_frame_width
!= FRAME_WIDTH (f
))
4872 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
4874 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
4875 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
4876 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
4878 #ifdef HAVE_WINDOW_SYSTEM
4879 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
4880 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
4885 /* Now, free glyph matrices in windows that were not reused. */
4886 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
4888 if (NILP (leaf_windows
[i
]->buffer
))
4890 /* Assert it's not reused as a combination. */
4891 xassert (NILP (leaf_windows
[i
]->hchild
)
4892 && NILP (leaf_windows
[i
]->vchild
));
4893 free_window_matrices (leaf_windows
[i
]);
4894 SET_FRAME_GARBAGED (f
);
4896 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
4900 /* If more than one window shows the new and old current buffer,
4901 don't try to preserve point in that buffer. */
4902 if (old_point
> 0 && n
> 1)
4909 /* Fselect_window will have made f the selected frame, so we
4910 reselect the proper frame here. Fhandle_switch_frame will change the
4911 selected window too, but that doesn't make the call to
4912 Fselect_window above totally superfluous; it still sets f's
4914 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
4915 do_switch_frame (data
->selected_frame
, Qnil
, 0);
4917 if (! NILP (Vwindow_configuration_change_hook
)
4918 && ! NILP (Vrun_hooks
))
4919 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4922 if (!NILP (new_current_buffer
))
4924 Fset_buffer (new_current_buffer
);
4926 /* If the buffer that is current now is the same
4927 that was current before setting the window configuration,
4928 don't alter its PT. */
4933 /* Restore the minimum heights recorded in the configuration. */
4934 window_min_height
= XINT (data
->min_height
);
4935 window_min_width
= XINT (data
->min_width
);
4937 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
4939 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
4942 /* Mark all windows now on frame as deleted
4943 by setting their buffers to nil. */
4946 delete_all_subwindows (w
)
4947 register struct window
*w
;
4949 if (!NILP (w
->next
))
4950 delete_all_subwindows (XWINDOW (w
->next
));
4951 if (!NILP (w
->vchild
))
4952 delete_all_subwindows (XWINDOW (w
->vchild
));
4953 if (!NILP (w
->hchild
))
4954 delete_all_subwindows (XWINDOW (w
->hchild
));
4956 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
4958 if (!NILP (w
->buffer
))
4961 /* We set all three of these fields to nil, to make sure that we can
4962 distinguish this dead window from any live window. Live leaf
4963 windows will have buffer set, and combination windows will have
4964 vchild or hchild set. */
4969 Vwindow_list
= Qnil
;
4973 count_windows (window
)
4974 register struct window
*window
;
4976 register int count
= 1;
4977 if (!NILP (window
->next
))
4978 count
+= count_windows (XWINDOW (window
->next
));
4979 if (!NILP (window
->vchild
))
4980 count
+= count_windows (XWINDOW (window
->vchild
));
4981 if (!NILP (window
->hchild
))
4982 count
+= count_windows (XWINDOW (window
->hchild
));
4987 /* Fill vector FLAT with leaf windows under W, starting at index I.
4988 Value is last index + 1. */
4991 get_leaf_windows (w
, flat
, i
)
4993 struct window
**flat
;
4998 if (!NILP (w
->hchild
))
4999 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5000 else if (!NILP (w
->vchild
))
5001 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5005 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5012 /* Return a pointer to the glyph W's physical cursor is on. Value is
5013 null if W's current matrix is invalid, so that no meaningfull glyph
5017 get_phys_cursor_glyph (w
)
5020 struct glyph_row
*row
;
5021 struct glyph
*glyph
;
5023 if (w
->phys_cursor
.vpos
>= 0
5024 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5025 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5027 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5028 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5037 save_window_save (window
, vector
, i
)
5039 struct Lisp_Vector
*vector
;
5042 register struct saved_window
*p
;
5043 register struct window
*w
;
5044 register Lisp_Object tem
;
5046 for (;!NILP (window
); window
= w
->next
)
5048 p
= SAVED_WINDOW_N (vector
, i
);
5049 w
= XWINDOW (window
);
5051 XSETFASTINT (w
->temslot
, i
++);
5053 p
->buffer
= w
->buffer
;
5056 p
->width
= w
->width
;
5057 p
->height
= w
->height
;
5058 p
->hscroll
= w
->hscroll
;
5059 p
->display_table
= w
->display_table
;
5060 p
->orig_top
= w
->orig_top
;
5061 p
->orig_height
= w
->orig_height
;
5062 if (!NILP (w
->buffer
))
5064 /* Save w's value of point in the window configuration.
5065 If w is the selected window, then get the value of point
5066 from the buffer; pointm is garbage in the selected window. */
5067 if (EQ (window
, selected_window
))
5069 p
->pointm
= Fmake_marker ();
5070 set_marker_both (p
->pointm
, w
->buffer
,
5071 BUF_PT (XBUFFER (w
->buffer
)),
5072 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5075 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5077 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5078 p
->start_at_line_beg
= w
->start_at_line_beg
;
5080 tem
= XBUFFER (w
->buffer
)->mark
;
5081 p
->mark
= Fcopy_marker (tem
, Qnil
);
5088 p
->start_at_line_beg
= Qnil
;
5091 if (NILP (w
->parent
))
5094 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5099 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5101 if (!NILP (w
->vchild
))
5102 i
= save_window_save (w
->vchild
, vector
, i
);
5103 if (!NILP (w
->hchild
))
5104 i
= save_window_save (w
->hchild
, vector
, i
);
5110 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5111 Scurrent_window_configuration
, 0, 1, 0,
5112 "Return an object representing the current window configuration of FRAME.\n\
5113 If FRAME is nil or omitted, use the selected frame.\n\
5114 This describes the number of windows, their sizes and current buffers,\n\
5115 and for each displayed buffer, where display starts, and the positions of\n\
5116 point and mark. An exception is made for point in the current buffer:\n\
5117 its value is -not- saved.\n\
5118 This also records the currently selected frame, and FRAME's focus\n\
5119 redirection (see `redirect-frame-focus').")
5123 register Lisp_Object tem
;
5124 register int n_windows
;
5125 register struct save_window_data
*data
;
5126 register struct Lisp_Vector
*vec
;
5131 frame
= selected_frame
;
5132 CHECK_LIVE_FRAME (frame
, 0);
5135 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5136 vec
= allocate_vectorlike (VECSIZE (struct save_window_data
));
5137 for (i
= 0; i
< VECSIZE (struct save_window_data
); i
++)
5138 vec
->contents
[i
] = Qnil
;
5139 vec
->size
= VECSIZE (struct save_window_data
);
5140 data
= (struct save_window_data
*)vec
;
5142 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
5143 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
5144 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
5145 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
5146 data
->selected_frame
= selected_frame
;
5147 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5148 XSETBUFFER (data
->current_buffer
, current_buffer
);
5149 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
5150 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5151 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5152 XSETINT (data
->min_height
, window_min_height
);
5153 XSETINT (data
->min_width
, window_min_width
);
5154 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5155 data
->saved_windows
= tem
;
5156 for (i
= 0; i
< n_windows
; i
++)
5157 XVECTOR (tem
)->contents
[i
]
5158 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
5159 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5160 XSETWINDOW_CONFIGURATION (tem
, data
);
5164 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
5166 "Execute body, preserving window sizes and contents.\n\
5167 Restore which buffer appears in which window, where display starts,\n\
5168 and the value of point and mark for each window.\n\
5169 Also restore the choice of selected window.\n\
5170 Also restore which buffer is current.\n\
5171 Does not restore the value of point in current buffer.")
5175 register Lisp_Object val
;
5176 register int count
= specpdl_ptr
- specpdl
;
5178 record_unwind_protect (Fset_window_configuration
,
5179 Fcurrent_window_configuration (Qnil
));
5180 val
= Fprogn (args
);
5181 return unbind_to (count
, val
);
5185 /***********************************************************************
5187 ***********************************************************************/
5189 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5191 "Set width of marginal areas of window WINDOW.\n\
5192 If window is nil, set margins of the currently selected window.\n\
5193 First parameter LEFT-WIDTH specifies the number of character\n\
5194 cells to reserve for the left marginal area. Second parameter\n\
5195 RIGHT-WIDTH does the same for the right marginal area.\n\
5196 A nil width parameter means no margin.")
5197 (window
, left
, right
)
5198 Lisp_Object window
, left
, right
;
5200 struct window
*w
= decode_window (window
);
5203 CHECK_NUMBER_OR_FLOAT (left
, 1);
5205 CHECK_NUMBER_OR_FLOAT (right
, 2);
5207 /* Check widths < 0 and translate a zero width to nil.
5208 Margins that are too wide have to be checked elsewhere. */
5209 if ((INTEGERP (left
) && XINT (left
) < 0)
5210 || (FLOATP (left
) && XFLOAT_DATA (left
) <= 0))
5211 XSETFASTINT (left
, 0);
5212 if (INTEGERP (left
) && XFASTINT (left
) == 0)
5215 if ((INTEGERP (right
) && XINT (right
) < 0)
5216 || (FLOATP (right
) && XFLOAT_DATA (right
) <= 0))
5217 XSETFASTINT (right
, 0);
5218 if (INTEGERP (right
) && XFASTINT (right
) == 0)
5221 w
->left_margin_width
= left
;
5222 w
->right_margin_width
= right
;
5224 ++windows_or_buffers_changed
;
5225 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
5230 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
5232 "Get width of marginal areas of window WINDOW.\n\
5233 If WINDOW is omitted or nil, use the currently selected window.\n\
5234 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).\n\
5235 If a marginal area does not exist, its width will be returned\n\
5240 struct window
*w
= decode_window (window
);
5241 return Fcons (w
->left_margin_width
, w
->right_margin_width
);
5246 /***********************************************************************
5248 ***********************************************************************/
5250 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 1, 0,
5251 "Return the amount by which WINDOW is scrolled vertically.\n\
5252 Use the selected window if WINDOW is nil or omitted.\n\
5253 Value is a multiple of the canonical character height of WINDOW.")
5262 window
= selected_window
;
5264 CHECK_WINDOW (window
, 0);
5265 w
= XWINDOW (window
);
5266 f
= XFRAME (w
->frame
);
5268 if (FRAME_WINDOW_P (f
))
5269 result
= CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
);
5271 result
= make_number (0);
5276 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
5278 "Set amount by which WINDOW should be scrolled vertically to VSCROLL.\n\
5279 WINDOW nil or omitted means use the selected window. VSCROLL is a\n\
5280 non-negative multiple of the canonical character height of WINDOW.")
5282 Lisp_Object window
, vscroll
;
5288 window
= selected_window
;
5290 CHECK_WINDOW (window
, 0);
5291 CHECK_NUMBER_OR_FLOAT (vscroll
, 1);
5293 w
= XWINDOW (window
);
5294 f
= XFRAME (w
->frame
);
5296 if (FRAME_WINDOW_P (f
))
5298 int old_dy
= w
->vscroll
;
5300 w
->vscroll
= - CANON_Y_UNIT (f
) * XFLOATINT (vscroll
);
5301 w
->vscroll
= min (w
->vscroll
, 0);
5303 /* Adjust glyph matrix of the frame if the virtual display
5304 area becomes larger than before. */
5305 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
5308 /* Prevent redisplay shortcuts. */
5309 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5312 return Fwindow_vscroll (window
);
5316 /* Call FN for all leaf windows on frame F. FN is called with the
5317 first argument being a pointer to the leaf window, and with
5318 additional argument USER_DATA. Stops when FN returns 0. */
5321 foreach_window (f
, fn
, user_data
)
5323 int (* fn
) P_ ((struct window
*, void *));
5326 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
5330 /* Helper function for foreach_window. Call FN for all leaf windows
5331 reachable from W. FN is called with the first argument being a
5332 pointer to the leaf window, and with additional argument USER_DATA.
5333 Stop when FN returns 0. Value is 0 if stopped by FN. */
5336 foreach_window_1 (w
, fn
, user_data
)
5338 int (* fn
) P_ ((struct window
*, void *));
5343 for (cont
= 1; w
&& cont
;)
5345 if (!NILP (w
->hchild
))
5346 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
5347 else if (!NILP (w
->vchild
))
5348 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
5350 cont
= fn (w
, user_data
);
5352 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5359 /* Freeze or unfreeze the window start of W if unless it is a
5360 mini-window or the selected window. FREEZE_P non-null means freeze
5361 the window start. */
5364 freeze_window_start (w
, freeze_p
)
5368 if (w
== XWINDOW (selected_window
)
5369 || MINI_WINDOW_P (w
)
5370 || (MINI_WINDOW_P (XWINDOW (selected_window
))
5371 && ! NILP (Vminibuf_scroll_window
)
5372 && w
== XWINDOW (Vminibuf_scroll_window
)))
5375 w
->frozen_window_start_p
= freeze_p
!= NULL
;
5380 /* Freeze or unfreeze the window starts of all leaf windows on frame
5381 F, except the selected window and a mini-window. FREEZE_P non-zero
5382 means freeze the window start. */
5385 freeze_window_starts (f
, freeze_p
)
5389 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
5393 /***********************************************************************
5395 ***********************************************************************/
5397 /* Return 1 if window configurations C1 and C2
5398 describe the same state of affairs. This is used by Fequal. */
5401 compare_window_configurations (c1
, c2
, ignore_positions
)
5403 int ignore_positions
;
5405 register struct save_window_data
*d1
, *d2
;
5406 struct Lisp_Vector
*sw1
, *sw2
;
5409 if (!WINDOW_CONFIGURATIONP (c1
))
5410 wrong_type_argument (Qwindow_configuration_p
, c1
);
5411 if (!WINDOW_CONFIGURATIONP (c2
))
5412 wrong_type_argument (Qwindow_configuration_p
, c2
);
5414 d1
= (struct save_window_data
*) XVECTOR (c1
);
5415 d2
= (struct save_window_data
*) XVECTOR (c2
);
5416 sw1
= XVECTOR (d1
->saved_windows
);
5417 sw2
= XVECTOR (d2
->saved_windows
);
5419 if (! EQ (d1
->frame_width
, d2
->frame_width
))
5421 if (! EQ (d1
->frame_height
, d2
->frame_height
))
5423 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
5425 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
5427 /* Don't compare the current_window field directly.
5428 Instead see w1_is_current and w2_is_current, below. */
5429 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
5431 if (! ignore_positions
)
5432 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
5434 /* Don't compare the root_window field.
5435 We don't require the two configurations
5436 to use the same window object,
5437 and the two root windows must be equivalent
5438 if everything else compares equal. */
5439 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
5441 if (! EQ (d1
->min_width
, d2
->min_width
))
5443 if (! EQ (d1
->min_height
, d2
->min_height
))
5446 /* Verify that the two confis have the same number of windows. */
5447 if (sw1
->size
!= sw2
->size
)
5450 for (i
= 0; i
< sw1
->size
; i
++)
5452 struct saved_window
*p1
, *p2
;
5453 int w1_is_current
, w2_is_current
;
5455 p1
= SAVED_WINDOW_N (sw1
, i
);
5456 p2
= SAVED_WINDOW_N (sw2
, i
);
5458 /* Verify that the current windows in the two
5459 configurations correspond to each other. */
5460 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
5461 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
5463 if (w1_is_current
!= w2_is_current
)
5466 /* Verify that the corresponding windows do match. */
5467 if (! EQ (p1
->buffer
, p2
->buffer
))
5469 if (! EQ (p1
->left
, p2
->left
))
5471 if (! EQ (p1
->top
, p2
->top
))
5473 if (! EQ (p1
->width
, p2
->width
))
5475 if (! EQ (p1
->height
, p2
->height
))
5477 if (! EQ (p1
->display_table
, p2
->display_table
))
5479 if (! EQ (p1
->parent
, p2
->parent
))
5481 if (! EQ (p1
->prev
, p2
->prev
))
5483 if (! ignore_positions
)
5485 if (! EQ (p1
->hscroll
, p2
->hscroll
))
5487 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
5489 if (NILP (Fequal (p1
->start
, p2
->start
)))
5491 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
5493 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
5501 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
5502 Scompare_window_configurations
, 2, 2, 0,
5503 "Compare two window configurations as regards the structure of windows.\n\
5504 This function ignores details such as the values of point and mark\n\
5505 and scrolling positions.")
5509 if (compare_window_configurations (x
, y
, 1))
5517 struct frame
*f
= make_terminal_frame ();
5518 XSETFRAME (selected_frame
, f
);
5519 Vterminal_frame
= selected_frame
;
5520 minibuf_window
= f
->minibuffer_window
;
5521 selected_window
= f
->selected_window
;
5522 last_nonminibuf_frame
= f
;
5524 window_initialized
= 1;
5530 Vwindow_list
= Qnil
;
5536 Qleft_bitmap_area
= intern ("left-bitmap-area");
5537 staticpro (&Qleft_bitmap_area
);
5538 Qright_bitmap_area
= intern ("right-bitmap-area");
5539 staticpro (&Qright_bitmap_area
);
5541 Qwindow_size_fixed
= intern ("window-size-fixed");
5542 staticpro (&Qwindow_size_fixed
);
5544 staticpro (&Qwindow_configuration_change_hook
);
5545 Qwindow_configuration_change_hook
5546 = intern ("window-configuration-change-hook");
5548 Qwindowp
= intern ("windowp");
5549 staticpro (&Qwindowp
);
5551 Qwindow_configuration_p
= intern ("window-configuration-p");
5552 staticpro (&Qwindow_configuration_p
);
5554 Qwindow_live_p
= intern ("window-live-p");
5555 staticpro (&Qwindow_live_p
);
5557 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
5558 staticpro (&Qtemp_buffer_show_hook
);
5560 staticpro (&Vwindow_list
);
5562 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
5563 "Non-nil means call as function to display a help buffer.\n\
5564 The function is called with one argument, the buffer to be displayed.\n\
5565 Used by `with-output-to-temp-buffer'.\n\
5566 If this function is used, then it must do the entire job of showing\n\
5567 the buffer; `temp-buffer-show-hook' is not run unless this function runs it.");
5568 Vtemp_buffer_show_function
= Qnil
;
5570 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
5571 "If non-nil, function to call to handle `display-buffer'.\n\
5572 It will receive two args, the buffer and a flag which if non-nil means\n\
5573 that the currently selected window is not acceptable.\n\
5574 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
5575 work using this function.");
5576 Vdisplay_buffer_function
= Qnil
;
5578 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
5579 "*If non-nil, `display-buffer' should even the window heights.\n\
5580 If nil, `display-buffer' will leave the window configuration alone.");
5581 Veven_window_heights
= Qt
;
5583 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
5584 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
5585 Vminibuf_scroll_window
= Qnil
;
5587 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
5588 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
5589 Vother_window_scroll_buffer
= Qnil
;
5591 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
5592 "*Non-nil means `display-buffer' should make a separate frame.");
5595 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
5596 "*Non-nil means `display-buffer' should reuse frames.\n\
5597 If the buffer in question is already displayed in a frame, raise that frame.");
5598 display_buffer_reuse_frames
= 0;
5600 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
5601 "Function to call to handle automatic new frame creation.\n\
5602 It is called with no arguments and should return a newly created frame.\n\
5604 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
5605 where `pop-up-frame-alist' would hold the default frame parameters.");
5606 Vpop_up_frame_function
= Qnil
;
5608 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
5609 "*List of buffer names that should have their own special frames.\n\
5610 Displaying a buffer whose name is in this list makes a special frame for it\n\
5611 using `special-display-function'. See also `special-display-regexps'.\n\
5613 An element of the list can be a list instead of just a string.\n\
5614 There are two ways to use a list as an element:\n\
5615 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)\n\
5616 In the first case, FRAME-PARAMETERS are used to create the frame.\n\
5617 In the latter case, FUNCTION is called with BUFFER as the first argument,\n\
5618 followed by OTHER-ARGS--it can display BUFFER in any way it likes.\n\
5619 All this is done by the function found in `special-display-function'.\n\
5621 If this variable appears \"not to work\", because you add a name to it\n\
5622 but that buffer still appears in the selected window, look at the\n\
5623 values of `same-window-buffer-names' and `same-window-regexps'.\n\
5624 Those variables take precedence over this one.");
5625 Vspecial_display_buffer_names
= Qnil
;
5627 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
5628 "*List of regexps saying which buffers should have their own special frames.\n\
5629 If a buffer name matches one of these regexps, it gets its own frame.\n\
5630 Displaying a buffer whose name is in this list makes a special frame for it\n\
5631 using `special-display-function'.\n\
5633 An element of the list can be a list instead of just a string.\n\
5634 There are two ways to use a list as an element:\n\
5635 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)\n\
5636 In the first case, FRAME-PARAMETERS are used to create the frame.\n\
5637 In the latter case, FUNCTION is called with the buffer as first argument,\n\
5638 followed by OTHER-ARGS--it can display the buffer in any way it likes.\n\
5639 All this is done by the function found in `special-display-function'.\n\
5641 If this variable appears \"not to work\", because you add a regexp to it\n\
5642 but the matching buffers still appear in the selected window, look at the\n\
5643 values of `same-window-buffer-names' and `same-window-regexps'.\n\
5644 Those variables take precedence over this one.");
5645 Vspecial_display_regexps
= Qnil
;
5647 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
5648 "Function to call to make a new frame for a special buffer.\n\
5649 It is called with two arguments, the buffer and optional buffer specific\n\
5650 data, and should return a window displaying that buffer.\n\
5651 The default value makes a separate frame for the buffer,\n\
5652 using `special-display-frame-alist' to specify the frame parameters.\n\
5654 A buffer is special if its is listed in `special-display-buffer-names'\n\
5655 or matches a regexp in `special-display-regexps'.");
5656 Vspecial_display_function
= Qnil
;
5658 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
5659 "*List of buffer names that should appear in the selected window.\n\
5660 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
5661 switches to it in the selected window, rather than making it appear\n\
5662 in some other window.\n\
5664 An element of the list can be a cons cell instead of just a string.\n\
5665 Then the car must be a string, which specifies the buffer name.\n\
5666 This is for compatibility with `special-display-buffer-names';\n\
5667 the cdr of the cons cell is ignored.\n\
5669 See also `same-window-regexps'.");
5670 Vsame_window_buffer_names
= Qnil
;
5672 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
5673 "*List of regexps saying which buffers should appear in the selected window.\n\
5674 If a buffer name matches one of these regexps, then displaying it\n\
5675 using `display-buffer' or `pop-to-buffer' switches to it\n\
5676 in the selected window, rather than making it appear in some other window.\n\
5678 An element of the list can be a cons cell instead of just a string.\n\
5679 Then the car must be a string, which specifies the buffer name.\n\
5680 This is for compatibility with `special-display-buffer-names';\n\
5681 the cdr of the cons cell is ignored.\n\
5683 See also `same-window-buffer-names'.");
5684 Vsame_window_regexps
= Qnil
;
5686 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
5687 "*Non-nil means display-buffer should make new windows.");
5690 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
5691 "*Number of lines of continuity when scrolling by screenfuls.");
5692 next_screen_context_lines
= 2;
5694 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
5695 "*display-buffer would prefer to split the largest window if this large.\n\
5696 If there is only one window, it is split regardless of this value.");
5697 split_height_threshold
= 500;
5699 DEFVAR_INT ("window-min-height", &window_min_height
,
5700 "*Delete any window less than this tall (including its mode line).");
5701 window_min_height
= 4;
5703 DEFVAR_INT ("window-min-width", &window_min_width
,
5704 "*Delete any window less than this wide.");
5705 window_min_width
= 10;
5707 DEFVAR_LISP ("scroll-preserve-screen-position",
5708 &Vscroll_preserve_screen_position
,
5709 "*Nonzero means scroll commands move point to keep its screen line unchanged.");
5710 Vscroll_preserve_screen_position
= Qnil
;
5712 DEFVAR_LISP ("window-configuration-change-hook",
5713 &Vwindow_configuration_change_hook
,
5714 "Functions to call when window configuration changes.\n\
5715 The selected frame is the one whose configuration has changed.");
5716 Vwindow_configuration_change_hook
= Qnil
;
5718 defsubr (&Sselected_window
);
5719 defsubr (&Sminibuffer_window
);
5720 defsubr (&Swindow_minibuffer_p
);
5721 defsubr (&Swindowp
);
5722 defsubr (&Swindow_live_p
);
5723 defsubr (&Spos_visible_in_window_p
);
5724 defsubr (&Swindow_buffer
);
5725 defsubr (&Swindow_height
);
5726 defsubr (&Swindow_width
);
5727 defsubr (&Swindow_hscroll
);
5728 defsubr (&Sset_window_hscroll
);
5729 defsubr (&Swindow_redisplay_end_trigger
);
5730 defsubr (&Sset_window_redisplay_end_trigger
);
5731 defsubr (&Swindow_edges
);
5732 defsubr (&Scoordinates_in_window_p
);
5733 defsubr (&Swindow_at
);
5734 defsubr (&Swindow_point
);
5735 defsubr (&Swindow_start
);
5736 defsubr (&Swindow_end
);
5737 defsubr (&Sset_window_point
);
5738 defsubr (&Sset_window_start
);
5739 defsubr (&Swindow_dedicated_p
);
5740 defsubr (&Sset_window_dedicated_p
);
5741 defsubr (&Swindow_display_table
);
5742 defsubr (&Sset_window_display_table
);
5743 defsubr (&Snext_window
);
5744 defsubr (&Sprevious_window
);
5745 defsubr (&Sother_window
);
5746 defsubr (&Sget_lru_window
);
5747 defsubr (&Sget_largest_window
);
5748 defsubr (&Sget_buffer_window
);
5749 defsubr (&Sdelete_other_windows
);
5750 defsubr (&Sdelete_windows_on
);
5751 defsubr (&Sreplace_buffer_in_windows
);
5752 defsubr (&Sdelete_window
);
5753 defsubr (&Sset_window_buffer
);
5754 defsubr (&Sselect_window
);
5755 defsubr (&Sspecial_display_p
);
5756 defsubr (&Ssame_window_p
);
5757 defsubr (&Sdisplay_buffer
);
5758 defsubr (&Ssplit_window
);
5759 defsubr (&Senlarge_window
);
5760 defsubr (&Sshrink_window
);
5761 defsubr (&Sscroll_up
);
5762 defsubr (&Sscroll_down
);
5763 defsubr (&Sscroll_left
);
5764 defsubr (&Sscroll_right
);
5765 defsubr (&Sother_window_for_scrolling
);
5766 defsubr (&Sscroll_other_window
);
5767 defsubr (&Srecenter
);
5768 defsubr (&Swindow_text_height
);
5769 defsubr (&Smove_to_window_line
);
5770 defsubr (&Swindow_configuration_p
);
5771 defsubr (&Swindow_configuration_frame
);
5772 defsubr (&Sset_window_configuration
);
5773 defsubr (&Scurrent_window_configuration
);
5774 defsubr (&Ssave_window_excursion
);
5775 defsubr (&Sset_window_margins
);
5776 defsubr (&Swindow_margins
);
5777 defsubr (&Swindow_vscroll
);
5778 defsubr (&Sset_window_vscroll
);
5779 defsubr (&Scompare_window_configurations
);
5780 defsubr (&Swindow_list
);
5786 initial_define_key (control_x_map
, '1', "delete-other-windows");
5787 initial_define_key (control_x_map
, '2', "split-window");
5788 initial_define_key (control_x_map
, '0', "delete-window");
5789 initial_define_key (control_x_map
, 'o', "other-window");
5790 initial_define_key (control_x_map
, '^', "enlarge-window");
5791 initial_define_key (control_x_map
, '<', "scroll-left");
5792 initial_define_key (control_x_map
, '>', "scroll-right");
5794 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
5795 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
5796 initial_define_key (meta_map
, 'v', "scroll-down");
5798 initial_define_key (global_map
, Ctl('L'), "recenter");
5799 initial_define_key (meta_map
, 'r', "move-to-window-line");