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, 2001, 2002
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. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
51 /* Values returned from coordinates_in_window. */
67 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
68 Lisp_Object Qwindow_size_fixed
;
69 extern Lisp_Object Qleft_margin
, Qright_margin
;
70 extern Lisp_Object Qheight
, Qwidth
;
72 static int displayed_window_lines
P_ ((struct window
*));
73 static struct window
*decode_window
P_ ((Lisp_Object
));
74 static Lisp_Object select_window_1
P_ ((Lisp_Object
, int));
75 static int count_windows
P_ ((struct window
*));
76 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
77 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
78 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
79 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
80 static int window_min_size_1
P_ ((struct window
*, int));
81 static int window_min_size
P_ ((struct window
*, int, int, int *));
82 static void size_window
P_ ((Lisp_Object
, int, int, int));
83 static int freeze_window_start
P_ ((struct window
*, void *));
84 static int window_fixed_size_p
P_ ((struct window
*, int, int));
85 static void enlarge_window
P_ ((Lisp_Object
, int, int, int));
86 static Lisp_Object window_list
P_ ((void));
87 static int add_window_to_list
P_ ((struct window
*, void *));
88 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
90 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
92 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
94 static int foreach_window_1
P_ ((struct window
*,
95 int (* fn
) (struct window
*, void *),
97 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
99 /* The value of `window-size-fixed'. */
101 int window_size_fixed
;
103 /* This is the window in which the terminal's cursor should
104 be left when nothing is being done with it. This must
105 always be a leaf window, and its buffer is selected by
106 the top level editing loop at the end of each command.
108 This value is always the same as
109 FRAME_SELECTED_WINDOW (selected_frame). */
111 Lisp_Object selected_window
;
113 /* A list of all windows for use by next_window and Fwindow_list.
114 Functions creating or deleting windows should invalidate this cache
115 by setting it to nil. */
117 Lisp_Object Vwindow_list
;
119 /* The mini-buffer window of the selected frame.
120 Note that you cannot test for mini-bufferness of an arbitrary window
121 by comparing against this; but you can test for mini-bufferness of
122 the selected window. */
124 Lisp_Object minibuf_window
;
126 /* Non-nil means it is the window whose mode line should be
127 shown as the selected window when the minibuffer is selected. */
129 Lisp_Object minibuf_selected_window
;
131 /* Non-nil means it is the window for C-M-v to scroll
132 when the mini-buffer is selected. */
134 Lisp_Object Vminibuf_scroll_window
;
136 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
138 Lisp_Object Vother_window_scroll_buffer
;
140 /* Non-nil means it's function to call to display temp buffers. */
142 Lisp_Object Vtemp_buffer_show_function
;
144 /* Non-zero means to use mode-line-inactive face in all windows but the
145 selected-window and the minibuffer-scroll-window when the
146 minibuffer is active. */
147 int mode_line_in_non_selected_windows
;
149 /* If a window gets smaller than either of these, it is removed. */
151 EMACS_INT window_min_height
;
152 EMACS_INT window_min_width
;
154 /* Nonzero implies Fdisplay_buffer should create windows. */
158 /* Nonzero implies make new frames for Fdisplay_buffer. */
162 /* Nonzero means reuse existing frames for displaying buffers. */
164 int display_buffer_reuse_frames
;
166 /* Non-nil means use this function instead of default */
168 Lisp_Object Vpop_up_frame_function
;
170 /* Function to call to handle Fdisplay_buffer. */
172 Lisp_Object Vdisplay_buffer_function
;
174 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
176 Lisp_Object Veven_window_heights
;
178 /* List of buffer *names* for buffers that should have their own frames. */
180 Lisp_Object Vspecial_display_buffer_names
;
182 /* List of regexps for buffer names that should have their own frames. */
184 Lisp_Object Vspecial_display_regexps
;
186 /* Function to pop up a special frame. */
188 Lisp_Object Vspecial_display_function
;
190 /* List of buffer *names* for buffers to appear in selected window. */
192 Lisp_Object Vsame_window_buffer_names
;
194 /* List of regexps for buffer names to appear in selected window. */
196 Lisp_Object Vsame_window_regexps
;
198 /* Hook run at end of temp_output_buffer_show. */
200 Lisp_Object Qtemp_buffer_show_hook
;
202 /* Fdisplay_buffer always splits the largest window
203 if that window is more than this high. */
205 EMACS_INT split_height_threshold
;
207 /* Number of lines of continuity in scrolling by screenfuls. */
209 EMACS_INT next_screen_context_lines
;
211 /* Incremented for each window created. */
213 static int sequence_number
;
215 /* Nonzero after init_window_once has finished. */
217 static int window_initialized
;
219 /* Hook to run when window config changes. */
221 Lisp_Object Qwindow_configuration_change_hook
;
222 Lisp_Object Vwindow_configuration_change_hook
;
224 /* Nonzero means scroll commands try to put point
225 at the same screen height as previously. */
227 Lisp_Object Vscroll_preserve_screen_position
;
229 #if 0 /* This isn't used anywhere. */
230 /* Nonzero means we can split a frame even if it is "unsplittable". */
231 static int inhibit_frame_unsplittable
;
234 extern EMACS_INT scroll_margin
;
236 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
238 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
239 doc
: /* Returns t if OBJECT is a window. */)
243 return WINDOWP (object
) ? Qt
: Qnil
;
246 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
247 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
251 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
258 register struct window
*p
;
260 p
= allocate_window ();
261 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
262 XSETFASTINT (p
->left
, 0);
263 XSETFASTINT (p
->top
, 0);
264 XSETFASTINT (p
->height
, 0);
265 XSETFASTINT (p
->width
, 0);
266 XSETFASTINT (p
->hscroll
, 0);
267 XSETFASTINT (p
->min_hscroll
, 0);
268 p
->orig_top
= p
->orig_height
= Qnil
;
269 p
->start
= Fmake_marker ();
270 p
->pointm
= Fmake_marker ();
271 XSETFASTINT (p
->use_time
, 0);
273 p
->display_table
= Qnil
;
275 p
->pseudo_window_p
= 0;
276 bzero (&p
->cursor
, sizeof (p
->cursor
));
277 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
278 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
279 p
->desired_matrix
= p
->current_matrix
= 0;
280 p
->phys_cursor_type
= -1;
281 p
->phys_cursor_width
= -1;
282 p
->must_be_updated_p
= 0;
283 XSETFASTINT (p
->window_end_vpos
, 0);
284 XSETFASTINT (p
->window_end_pos
, 0);
285 p
->window_end_valid
= Qnil
;
288 XSETFASTINT (p
->last_point
, 0);
289 p
->frozen_window_start_p
= 0;
290 p
->height_fixed_p
= 0;
291 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
297 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
298 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
301 return selected_window
;
304 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
305 doc
: /* Return the window used now for minibuffers.
306 If the optional argument FRAME is specified, return the minibuffer window
307 used by that frame. */)
312 frame
= selected_frame
;
313 CHECK_LIVE_FRAME (frame
);
314 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
317 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
318 doc
: /* Returns non-nil if WINDOW is a minibuffer window. */)
322 struct window
*w
= decode_window (window
);
323 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
327 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
328 Spos_visible_in_window_p
, 0, 3, 0,
329 doc
: /* Return t if position POS is currently on the frame in WINDOW.
330 Return nil if that position is scrolled vertically out of view.
331 If a character is only partially visible, nil is returned, unless the
332 optional argument PARTIALLY is non-nil.
333 POS defaults to point in WINDOW; WINDOW defaults to the selected window. */)
334 (pos
, window
, partially
)
335 Lisp_Object pos
, window
, partially
;
337 register struct window
*w
;
339 register struct buffer
*buf
;
341 Lisp_Object in_window
;
344 w
= decode_window (window
);
345 buf
= XBUFFER (w
->buffer
);
346 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
350 CHECK_NUMBER_COERCE_MARKER (pos
);
353 else if (w
== XWINDOW (selected_window
))
356 posint
= XMARKER (w
->pointm
)->charpos
;
358 /* If position is above window start, it's not visible. */
359 if (posint
< CHARPOS (top
))
361 else if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
)
362 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (buf
)
363 && posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
))
365 /* If frame is up-to-date, and POSINT is < window end pos, use
366 that info. This doesn't work for POSINT == end pos, because
367 the window end pos is actually the position _after_ the last
368 char in the window. */
369 if (NILP (partially
))
371 pos_visible_p (w
, posint
, &fully_p
, NILP (partially
));
372 in_window
= fully_p
? Qt
: Qnil
;
377 else if (posint
> BUF_ZV (buf
))
379 else if (CHARPOS (top
) < BUF_BEGV (buf
) || CHARPOS (top
) > BUF_ZV (buf
))
380 /* If window start is out of range, do something reasonable. */
384 if (pos_visible_p (w
, posint
, &fully_p
, NILP (partially
)))
385 in_window
= !NILP (partially
) || fully_p
? Qt
: Qnil
;
394 static struct window
*
395 decode_window (window
)
396 register Lisp_Object window
;
399 return XWINDOW (selected_window
);
401 CHECK_LIVE_WINDOW (window
);
402 return XWINDOW (window
);
405 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
406 doc
: /* Return the buffer that WINDOW is displaying. */)
410 return decode_window (window
)->buffer
;
413 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
414 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
418 return decode_window (window
)->height
;
421 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
422 doc
: /* Return the number of display columns in WINDOW.
423 This is the width that is usable columns available for text in WINDOW.
424 If you want to find out how many columns WINDOW takes up,
425 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
429 return make_number (window_internal_width (decode_window (window
)));
432 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
433 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
437 return decode_window (window
)->hscroll
;
440 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
441 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
442 NCOL should be zero or positive.
444 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
445 window so that the location of point becomes invisible. */)
447 Lisp_Object window
, ncol
;
449 struct window
*w
= decode_window (window
);
453 hscroll
= max (0, XINT (ncol
));
455 /* Prevent redisplay shortcuts when changing the hscroll. */
456 if (XINT (w
->hscroll
) != hscroll
)
457 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
459 w
->hscroll
= make_number (hscroll
);
463 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
464 Swindow_redisplay_end_trigger
, 0, 1, 0,
465 doc
: /* Return WINDOW's redisplay end trigger value.
466 See `set-window-redisplay-end-trigger' for more information. */)
470 return decode_window (window
)->redisplay_end_trigger
;
473 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
474 Sset_window_redisplay_end_trigger
, 2, 2, 0,
475 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
476 VALUE should be a buffer position (typically a marker) or nil.
477 If it is a buffer position, then if redisplay in WINDOW reaches a position
478 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
479 with two arguments: WINDOW, and the end trigger value.
480 Afterwards the end-trigger value is reset to nil. */)
482 register Lisp_Object window
, value
;
484 register struct window
*w
;
486 w
= decode_window (window
);
487 w
->redisplay_end_trigger
= value
;
491 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
492 doc
: /* Return a list of the edge coordinates of WINDOW.
493 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
494 RIGHT is one more than the rightmost column used by WINDOW,
495 and BOTTOM is one more than the bottommost row used by WINDOW
496 and its mode-line. */)
500 register struct window
*w
= decode_window (window
);
502 return Fcons (w
->left
, Fcons (w
->top
,
503 Fcons (make_number (WINDOW_RIGHT_EDGE (w
)),
504 Fcons (make_number (XFASTINT (w
->top
)
505 + XFASTINT (w
->height
)),
509 /* Test if the character at column *X, row *Y is within window W.
510 If it is not, return 0;
511 if it is in the window's text area,
512 set *x and *y to its location relative to the upper left corner
515 if it is on the window's modeline, return 2;
516 if it is on the border between the window and its right sibling,
518 if it is on the window's top line, return 4;
519 if it is in left or right fringe of the window,
520 return 5 or 6, and convert *X and *Y to window-relative coordinates;
521 if it is in the marginal area to the left/right of the window,
522 return 7 or 8, and convert *X and *Y to window-relative coordinates.
524 X and Y are frame relative pixel coordinates. */
526 static enum window_part
527 coordinates_in_window (w
, x
, y
)
528 register struct window
*w
;
531 /* Let's make this a global enum later, instead of using numbers
533 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
534 int left_x
, right_x
, top_y
, bottom_y
;
535 enum window_part part
;
536 int ux
= CANON_X_UNIT (f
);
537 int x0
= XFASTINT (w
->left
) * ux
;
538 int x1
= x0
+ XFASTINT (w
->width
) * ux
;
539 /* The width of the area where the vertical line can be dragged.
540 (Between mode lines for instance. */
541 int grabbable_width
= ux
;
542 int lmargin_width
= 0, rmargin_width
= 0;
544 if (*x
< x0
|| *x
>= x1
)
547 /* In what's below, we subtract 1 when computing right_x because we
548 want the rightmost pixel, which is given by left_pixel+width-1. */
549 if (w
->pseudo_window_p
)
552 right_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
) - 1;
553 top_y
= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
554 bottom_y
= WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w
);
558 left_x
= (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
)
559 - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
));
560 right_x
= WINDOW_DISPLAY_RIGHT_EDGE_PIXEL_X (w
) - 1;
561 top_y
= (WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
)
562 - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
));
563 bottom_y
= WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w
);
566 /* On the mode line or header line? If it's near the start of
567 the mode or header line of window that's has a horizontal
568 sibling, say it's on the vertical line. That's to be able
569 to resize windows horizontally in case we're using toolkit
572 if (WINDOW_WANTS_MODELINE_P (w
)
573 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
576 /* We're somewhere on the mode line. We consider the place
577 between mode lines of horizontally adjacent mode lines
578 as the vertical border. If scroll bars on the left,
579 return the right window. */
582 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
584 if (abs (*x
- x0
) < grabbable_width
)
585 part
= ON_VERTICAL_BORDER
;
587 else if (!WINDOW_RIGHTMOST_P (w
) && abs (*x
- x1
) < grabbable_width
)
588 part
= ON_VERTICAL_BORDER
;
590 else if (WINDOW_WANTS_HEADER_LINE_P (w
)
591 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
594 part
= ON_HEADER_LINE
;
596 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
598 if (abs (*x
- x0
) < grabbable_width
)
599 part
= ON_VERTICAL_BORDER
;
601 else if (!WINDOW_RIGHTMOST_P (w
) && abs (*x
- x1
) < grabbable_width
)
602 part
= ON_VERTICAL_BORDER
;
604 /* Outside anything interesting? */
608 - FRAME_LEFT_FRINGE_WIDTH (f
)
609 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * ux
)
611 + FRAME_RIGHT_FRINGE_WIDTH (f
)
612 + FRAME_RIGHT_SCROLL_BAR_WIDTH (f
) * ux
))
616 else if (FRAME_WINDOW_P (f
))
618 if (!w
->pseudo_window_p
619 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
620 && !WINDOW_RIGHTMOST_P (w
)
621 && (abs (*x
- right_x
- FRAME_RIGHT_FRINGE_WIDTH (f
)) < grabbable_width
))
623 part
= ON_VERTICAL_BORDER
;
625 else if (*x
< left_x
|| *x
> right_x
)
627 /* Other lines than the mode line don't include fringes and
628 scroll bars on the left. */
630 /* Convert X and Y to window-relative pixel coordinates. */
633 part
= *x
< left_x
? ON_LEFT_FRINGE
: ON_RIGHT_FRINGE
;
637 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
638 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
639 /* You can never be on a margin area if its width is zero. */
641 && *x
<= window_box_right (w
, LEFT_MARGIN_AREA
))
642 part
= ON_LEFT_MARGIN
;
643 else if (rmargin_width
644 && *x
>= window_box_left (w
, RIGHT_MARGIN_AREA
))
645 part
= ON_RIGHT_MARGIN
;
656 /* Need to say "*x > right_x" rather than >=, since on character
657 terminals, the vertical line's x coordinate is right_x. */
658 if (*x
< left_x
|| *x
> right_x
)
660 /* Other lines than the mode line don't include fringes and
661 scroll bars on the left. */
663 /* Convert X and Y to window-relative pixel coordinates. */
666 part
= *x
< left_x
? ON_LEFT_FRINGE
: ON_RIGHT_FRINGE
;
668 /* Here, too, "*x > right_x" is because of character terminals. */
669 else if (!w
->pseudo_window_p
670 && !WINDOW_RIGHTMOST_P (w
)
671 && *x
> right_x
- ux
)
673 /* On the border on the right side of the window? Assume that
674 this area begins at RIGHT_X minus a canonical char width. */
675 part
= ON_VERTICAL_BORDER
;
679 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
680 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
681 /* You can never be on a margin area if its width is zero.
682 This is especially important for character terminals. */
684 && *x
<= window_box_right (w
, LEFT_MARGIN_AREA
))
685 part
= ON_LEFT_MARGIN
;
686 else if (rmargin_width
687 && *x
>= window_box_left (w
, RIGHT_MARGIN_AREA
))
688 part
= ON_RIGHT_MARGIN
;
692 /* Convert X and Y to window-relative pixel coordinates. */
703 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
704 Scoordinates_in_window_p
, 2, 2, 0,
705 doc
: /* Return non-nil if COORDINATES are in WINDOW.
706 COORDINATES is a cons of the form (X . Y), X and Y being distances
707 measured in characters from the upper-left corner of the frame.
708 \(0 . 0) denotes the character in the upper left corner of the
710 If COORDINATES are in the text portion of WINDOW,
711 the coordinates relative to the window are returned.
712 If they are in the mode line of WINDOW, `mode-line' is returned.
713 If they are in the top mode line of WINDOW, `header-line' is returned.
714 If they are in the left fringe of WINDOW, `left-fringe' is returned.
715 If they are in the right fringe of WINDOW, `right-fringe' is returned.
716 If they are on the border between WINDOW and its right sibling,
717 `vertical-line' is returned.
718 If they are in the windows's left or right marginal areas, `left-margin'\n\
719 or `right-margin' is returned. */)
720 (coordinates
, window
)
721 register Lisp_Object coordinates
, window
;
728 CHECK_LIVE_WINDOW (window
);
729 w
= XWINDOW (window
);
730 f
= XFRAME (w
->frame
);
731 CHECK_CONS (coordinates
);
732 lx
= Fcar (coordinates
);
733 ly
= Fcdr (coordinates
);
734 CHECK_NUMBER_OR_FLOAT (lx
);
735 CHECK_NUMBER_OR_FLOAT (ly
);
736 x
= PIXEL_X_FROM_CANON_X (f
, lx
);
737 y
= PIXEL_Y_FROM_CANON_Y (f
, ly
);
739 switch (coordinates_in_window (w
, &x
, &y
))
745 /* X and Y are now window relative pixel coordinates. Convert
746 them to canonical char units before returning them. */
747 return Fcons (CANON_X_FROM_PIXEL_X (f
, x
),
748 CANON_Y_FROM_PIXEL_Y (f
, y
));
753 case ON_VERTICAL_BORDER
:
754 return Qvertical_line
;
762 case ON_RIGHT_FRINGE
:
763 return Qright_fringe
;
768 case ON_RIGHT_MARGIN
:
769 return Qright_margin
;
777 /* Callback for foreach_window, used in window_from_coordinates.
778 Check if window W contains coordinates specified by USER_DATA which
779 is actually a pointer to a struct check_window_data CW.
781 Check if window W contains coordinates *CW->x and *CW->y. If it
782 does, return W in *CW->window, as Lisp_Object, and return in
783 *CW->part the part of the window under coordinates *X,*Y. Return
784 zero from this function to stop iterating over windows. */
786 struct check_window_data
793 check_window_containing (w
, user_data
)
797 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
798 enum window_part found
;
801 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
802 if (found
!= ON_NOTHING
)
804 *cw
->part
= found
- 1;
805 XSETWINDOW (*cw
->window
, w
);
813 /* Find the window containing frame-relative pixel position X/Y and
814 return it as a Lisp_Object. If X, Y is on the window's modeline,
815 set *PART to 1; if it is on the separating line between the window
816 and its right sibling, set it to 2; otherwise set it to 0. If
817 there is no window under X, Y return nil and leave *PART
818 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
820 This function was previously implemented with a loop cycling over
821 windows with Fnext_window, and starting with the frame's selected
822 window. It turned out that this doesn't work with an
823 implementation of next_window using Vwindow_list, because
824 FRAME_SELECTED_WINDOW (F) is not always contained in the window
825 tree of F when this function is called asynchronously from
826 note_mouse_highlight. The original loop didn't terminate in this
830 window_from_coordinates (f
, x
, y
, part
, tool_bar_p
)
837 struct check_window_data cw
;
840 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
841 foreach_window (f
, check_window_containing
, &cw
);
843 /* If not found above, see if it's in the tool bar window, if a tool
847 && WINDOWP (f
->tool_bar_window
)
848 && XINT (XWINDOW (f
->tool_bar_window
)->height
) > 0
849 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
853 window
= f
->tool_bar_window
;
859 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
860 doc
: /* Return window containing coordinates X and Y on FRAME.
861 If omitted, FRAME defaults to the currently selected frame.
862 The top left corner of the frame is considered to be row 0,
865 Lisp_Object x
, y
, frame
;
871 frame
= selected_frame
;
872 CHECK_LIVE_FRAME (frame
);
875 /* Check that arguments are integers or floats. */
876 CHECK_NUMBER_OR_FLOAT (x
);
877 CHECK_NUMBER_OR_FLOAT (y
);
879 return window_from_coordinates (f
,
880 PIXEL_X_FROM_CANON_X (f
, x
),
881 PIXEL_Y_FROM_CANON_Y (f
, y
),
885 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
886 doc
: /* Return current value of point in WINDOW.
887 For a nonselected window, this is the value point would have
888 if that window were selected.
890 Note that, when WINDOW is the selected window and its buffer
891 is also currently selected, the value returned is the same as (point).
892 It would be more strictly correct to return the `top-level' value
893 of point, outside of any save-excursion forms.
894 But that is hard to define. */)
898 register struct window
*w
= decode_window (window
);
900 if (w
== XWINDOW (selected_window
)
901 && current_buffer
== XBUFFER (w
->buffer
))
903 return Fmarker_position (w
->pointm
);
906 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
907 doc
: /* Return position at which display currently starts in WINDOW.
908 This is updated by redisplay or by calling `set-window-start'. */)
912 return Fmarker_position (decode_window (window
)->start
);
915 /* This is text temporarily removed from the doc string below.
917 This function returns nil if the position is not currently known.
918 That happens when redisplay is preempted and doesn't finish.
919 If in that case you want to compute where the end of the window would
920 have been if redisplay had finished, do this:
922 (goto-char (window-start window))
923 (vertical-motion (1- (window-height window)) window)
926 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
927 doc
: /* Return position at which display currently ends in WINDOW.
928 This is updated by redisplay, when it runs to completion.
929 Simply changing the buffer text or setting `window-start'
930 does not update this value.
931 If UPDATE is non-nil, compute the up-to-date position
932 if it isn't already recorded. */)
934 Lisp_Object window
, update
;
937 struct window
*w
= decode_window (window
);
943 #if 0 /* This change broke some things. We should make it later. */
944 /* If we don't know the end position, return nil.
945 The user can compute it with vertical-motion if he wants to.
946 It would be nicer to do it automatically,
947 but that's so slow that it would probably bother people. */
948 if (NILP (w
->window_end_valid
))
953 && ! (! NILP (w
->window_end_valid
)
954 && XFASTINT (w
->last_modified
) >= MODIFF
))
956 struct text_pos startp
;
958 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
960 /* In case W->start is out of the range, use something
961 reasonable. This situation occurred when loading a file with
962 `-l' containing a call to `rmail' with subsequent other
963 commands. At the end, W->start happened to be BEG, while
964 rmail had already narrowed the buffer. */
965 if (XMARKER (w
->start
)->charpos
< BEGV
)
966 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
967 else if (XMARKER (w
->start
)->charpos
> ZV
)
968 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
970 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
972 /* Cannot use Fvertical_motion because that function doesn't
973 cope with variable-height lines. */
974 if (b
!= current_buffer
)
976 old_buffer
= current_buffer
;
977 set_buffer_internal (b
);
980 start_display (&it
, w
, startp
);
981 move_it_vertically (&it
, window_box_height (w
));
982 if (it
.current_y
< it
.last_visible_y
)
983 move_it_past_eol (&it
);
984 value
= make_number (IT_CHARPOS (it
));
987 set_buffer_internal (old_buffer
);
990 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
995 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
996 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer. */)
998 Lisp_Object window
, pos
;
1000 register struct window
*w
= decode_window (window
);
1002 CHECK_NUMBER_COERCE_MARKER (pos
);
1003 if (w
== XWINDOW (selected_window
)
1004 && XBUFFER (w
->buffer
) == current_buffer
)
1007 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1009 /* We have to make sure that redisplay updates the window to show
1010 the new value of point. */
1011 if (!EQ (window
, selected_window
))
1012 ++windows_or_buffers_changed
;
1017 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1018 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1019 Optional third arg NOFORCE non-nil inhibits next redisplay
1020 from overriding motion of point in order to display at this exact start. */)
1021 (window
, pos
, noforce
)
1022 Lisp_Object window
, pos
, noforce
;
1024 register struct window
*w
= decode_window (window
);
1026 CHECK_NUMBER_COERCE_MARKER (pos
);
1027 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1028 /* this is not right, but much easier than doing what is right. */
1029 w
->start_at_line_beg
= Qnil
;
1031 w
->force_start
= Qt
;
1032 w
->update_mode_line
= Qt
;
1033 XSETFASTINT (w
->last_modified
, 0);
1034 XSETFASTINT (w
->last_overlay_modified
, 0);
1035 if (!EQ (window
, selected_window
))
1036 windows_or_buffers_changed
++;
1041 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1043 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1044 See also `set-window-dedicated-p'. */)
1048 return decode_window (window
)->dedicated
;
1051 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1052 Sset_window_dedicated_p
, 2, 2, 0,
1053 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1054 If it is dedicated, Emacs will not automatically change
1055 which buffer appears in it.
1056 The second argument is the new value for the dedication flag;
1057 non-nil means yes. */)
1059 Lisp_Object window
, arg
;
1061 register struct window
*w
= decode_window (window
);
1064 w
->dedicated
= Qnil
;
1068 return w
->dedicated
;
1071 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1073 doc
: /* Return the display-table that WINDOW is using. */)
1077 return decode_window (window
)->display_table
;
1080 /* Get the display table for use on window W. This is either W's
1081 display table or W's buffer's display table. Ignore the specified
1082 tables if they are not valid; if no valid table is specified,
1085 struct Lisp_Char_Table
*
1086 window_display_table (w
)
1089 struct Lisp_Char_Table
*dp
= NULL
;
1091 if (DISP_TABLE_P (w
->display_table
))
1092 dp
= XCHAR_TABLE (w
->display_table
);
1093 else if (BUFFERP (w
->buffer
))
1095 struct buffer
*b
= XBUFFER (w
->buffer
);
1097 if (DISP_TABLE_P (b
->display_table
))
1098 dp
= XCHAR_TABLE (b
->display_table
);
1099 else if (DISP_TABLE_P (Vstandard_display_table
))
1100 dp
= XCHAR_TABLE (Vstandard_display_table
);
1106 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1107 doc
: /* Set WINDOW's display-table to TABLE. */)
1109 register Lisp_Object window
, table
;
1111 register struct window
*w
;
1113 w
= decode_window (window
);
1114 w
->display_table
= table
;
1118 /* Record info on buffer window w is displaying
1119 when it is about to cease to display that buffer. */
1122 register struct window
*w
;
1129 if (b
!= XMARKER (w
->pointm
)->buffer
)
1133 if (w
== XWINDOW (selected_window
)
1134 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1135 /* Do this except when the selected window's buffer
1136 is being removed from some other window. */
1138 /* last_window_start records the start position that this buffer
1139 had in the last window to be disconnected from it.
1140 Now that this statement is unconditional,
1141 it is possible for the buffer to be displayed in the
1142 selected window, while last_window_start reflects another
1143 window which was recently showing the same buffer.
1144 Some people might say that might be a good thing. Let's see. */
1145 b
->last_window_start
= marker_position (w
->start
);
1147 /* Point in the selected window's buffer
1148 is actually stored in that buffer, and the window's pointm isn't used.
1149 So don't clobber point in that buffer. */
1150 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1151 /* This line helps to fix Horsley's testbug.el bug. */
1152 && !(WINDOWP (b
->last_selected_window
)
1153 && w
!= XWINDOW (b
->last_selected_window
)
1154 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1155 temp_set_point_both (b
,
1156 clip_to_bounds (BUF_BEGV (b
),
1157 XMARKER (w
->pointm
)->charpos
,
1159 clip_to_bounds (BUF_BEGV_BYTE (b
),
1160 marker_byte_position (w
->pointm
),
1163 if (WINDOWP (b
->last_selected_window
)
1164 && w
== XWINDOW (b
->last_selected_window
))
1165 b
->last_selected_window
= Qnil
;
1168 /* Put replacement into the window structure in place of old. */
1170 replace_window (old
, replacement
)
1171 Lisp_Object old
, replacement
;
1173 register Lisp_Object tem
;
1174 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1176 /* If OLD is its frame's root_window, then replacement is the new
1177 root_window for that frame. */
1179 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1180 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1184 p
->width
= o
->width
;
1185 p
->height
= o
->height
;
1186 p
->desired_matrix
= p
->current_matrix
= 0;
1188 bzero (&p
->cursor
, sizeof (p
->cursor
));
1189 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1190 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1191 p
->phys_cursor_type
= -1;
1192 p
->phys_cursor_width
= -1;
1193 p
->must_be_updated_p
= 0;
1194 p
->pseudo_window_p
= 0;
1195 XSETFASTINT (p
->window_end_vpos
, 0);
1196 XSETFASTINT (p
->window_end_pos
, 0);
1197 p
->window_end_valid
= Qnil
;
1198 p
->frozen_window_start_p
= 0;
1199 p
->orig_top
= p
->orig_height
= Qnil
;
1201 p
->next
= tem
= o
->next
;
1203 XWINDOW (tem
)->prev
= replacement
;
1205 p
->prev
= tem
= o
->prev
;
1207 XWINDOW (tem
)->next
= replacement
;
1209 p
->parent
= tem
= o
->parent
;
1212 if (EQ (XWINDOW (tem
)->vchild
, old
))
1213 XWINDOW (tem
)->vchild
= replacement
;
1214 if (EQ (XWINDOW (tem
)->hchild
, old
))
1215 XWINDOW (tem
)->hchild
= replacement
;
1218 /*** Here, if replacement is a vertical combination
1219 and so is its new parent, we should make replacement's
1220 children be children of that parent instead. ***/
1223 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1224 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1226 register Lisp_Object window
;
1228 delete_window (window
);
1230 if (! NILP (Vwindow_configuration_change_hook
)
1231 && ! NILP (Vrun_hooks
))
1232 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1238 delete_window (window
)
1239 register Lisp_Object window
;
1241 register Lisp_Object tem
, parent
, sib
;
1242 register struct window
*p
;
1243 register struct window
*par
;
1246 /* Because this function is called by other C code on non-leaf
1247 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1248 so we can't decode_window here. */
1250 window
= selected_window
;
1252 CHECK_WINDOW (window
);
1253 p
= XWINDOW (window
);
1255 /* It's okay to delete an already-deleted window. */
1256 if (NILP (p
->buffer
)
1258 && NILP (p
->vchild
))
1263 error ("Attempt to delete minibuffer or sole ordinary window");
1264 par
= XWINDOW (parent
);
1266 windows_or_buffers_changed
++;
1267 Vwindow_list
= Qnil
;
1268 f
= XFRAME (WINDOW_FRAME (p
));
1269 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1271 /* Are we trying to delete any frame's selected window? */
1273 Lisp_Object swindow
, pwindow
;
1275 /* See if the frame's selected window is either WINDOW
1276 or any subwindow of it, by finding all that window's parents
1277 and comparing each one with WINDOW. */
1278 swindow
= FRAME_SELECTED_WINDOW (f
);
1283 while (!NILP (pwindow
))
1285 if (EQ (window
, pwindow
))
1287 pwindow
= XWINDOW (pwindow
)->parent
;
1290 /* If the window being deleted is not a parent of SWINDOW,
1291 then SWINDOW is ok as the new selected window. */
1292 if (!EQ (window
, pwindow
))
1294 /* Otherwise, try another window for SWINDOW. */
1295 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1297 /* If we get back to the frame's selected window,
1298 it means there was no acceptable alternative,
1299 so we cannot delete. */
1300 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1301 error ("Cannot delete window");
1304 /* If we need to change SWINDOW, do it. */
1305 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1307 /* If we're about to delete the selected window on the
1308 selected frame, then we should use Fselect_window to select
1309 the new window. On the other hand, if we're about to
1310 delete the selected window on any other frame, we shouldn't do
1311 anything but set the frame's selected_window slot. */
1312 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1313 Fselect_window (swindow
);
1315 FRAME_SELECTED_WINDOW (f
) = swindow
;
1320 /* tem is null for dummy parent windows
1321 (which have inferiors but not any contents themselves) */
1325 unchain_marker (p
->pointm
);
1326 unchain_marker (p
->start
);
1329 /* Free window glyph matrices. It is sure that they are allocated
1330 again when ADJUST_GLYPHS is called. Block input so that expose
1331 events and other events that access glyph matrices are not
1332 processed while we are changing them. */
1334 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1338 XWINDOW (tem
)->prev
= p
->prev
;
1342 XWINDOW (tem
)->next
= p
->next
;
1344 if (EQ (window
, par
->hchild
))
1345 par
->hchild
= p
->next
;
1346 if (EQ (window
, par
->vchild
))
1347 par
->vchild
= p
->next
;
1349 /* Find one of our siblings to give our space to. */
1353 /* If p gives its space to its next sibling, that sibling needs
1354 to have its top/left side pulled back to where p's is.
1355 set_window_{height,width} will re-position the sibling's
1358 XWINDOW (sib
)->top
= p
->top
;
1359 XWINDOW (sib
)->left
= p
->left
;
1362 /* Stretch that sibling. */
1363 if (!NILP (par
->vchild
))
1364 set_window_height (sib
,
1365 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
1367 if (!NILP (par
->hchild
))
1368 set_window_width (sib
,
1369 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
1372 /* If parent now has only one child,
1373 put the child into the parent's place. */
1377 if (NILP (XWINDOW (tem
)->next
))
1378 replace_window (parent
, tem
);
1380 /* Since we may be deleting combination windows, we must make sure that
1381 not only p but all its children have been marked as deleted. */
1382 if (! NILP (p
->hchild
))
1383 delete_all_subwindows (XWINDOW (p
->hchild
));
1384 else if (! NILP (p
->vchild
))
1385 delete_all_subwindows (XWINDOW (p
->vchild
));
1387 /* Mark this window as deleted. */
1388 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1390 /* Adjust glyph matrices. */
1397 /***********************************************************************
1399 ***********************************************************************/
1401 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1402 pointer. This is a callback function for foreach_window, used in
1403 function window_list. */
1406 add_window_to_list (w
, user_data
)
1410 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1412 XSETWINDOW (window
, w
);
1413 *list
= Fcons (window
, *list
);
1418 /* Return a list of all windows, for use by next_window. If
1419 Vwindow_list is a list, return that list. Otherwise, build a new
1420 list, cache it in Vwindow_list, and return that. */
1425 if (!CONSP (Vwindow_list
))
1429 Vwindow_list
= Qnil
;
1430 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1432 Lisp_Object args
[2];
1434 /* We are visiting windows in canonical order, and add
1435 new windows at the front of args[1], which means we
1436 have to reverse this list at the end. */
1438 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1439 args
[0] = Vwindow_list
;
1440 args
[1] = Fnreverse (args
[1]);
1441 Vwindow_list
= Fnconc (2, args
);
1445 return Vwindow_list
;
1449 /* Value is non-zero if WINDOW satisfies the constraints given by
1450 OWINDOW, MINIBUF and ALL_FRAMES.
1452 MINIBUF t means WINDOW may be minibuffer windows.
1453 `lambda' means WINDOW may not be a minibuffer window.
1454 a window means a specific minibuffer window
1456 ALL_FRAMES t means search all frames,
1457 nil means search just current frame,
1458 `visible' means search just visible frames,
1459 0 means search visible and iconified frames,
1460 a window means search the frame that window belongs to,
1461 a frame means consider windows on that frame, only. */
1464 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1465 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1467 struct window
*w
= XWINDOW (window
);
1468 struct frame
*f
= XFRAME (w
->frame
);
1469 int candidate_p
= 1;
1471 if (!BUFFERP (w
->buffer
))
1473 else if (MINI_WINDOW_P (w
)
1474 && (EQ (minibuf
, Qlambda
)
1475 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1477 /* If MINIBUF is `lambda' don't consider any mini-windows.
1478 If it is a window, consider only that one. */
1481 else if (EQ (all_frames
, Qt
))
1483 else if (NILP (all_frames
))
1485 xassert (WINDOWP (owindow
));
1486 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1488 else if (EQ (all_frames
, Qvisible
))
1490 FRAME_SAMPLE_VISIBILITY (f
);
1491 candidate_p
= FRAME_VISIBLE_P (f
);
1493 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1495 FRAME_SAMPLE_VISIBILITY (f
);
1496 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1498 else if (WINDOWP (all_frames
))
1499 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1500 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1501 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1502 else if (FRAMEP (all_frames
))
1503 candidate_p
= EQ (all_frames
, w
->frame
);
1509 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1510 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1514 decode_next_window_args (window
, minibuf
, all_frames
)
1515 Lisp_Object
*window
, *minibuf
, *all_frames
;
1518 *window
= selected_window
;
1520 CHECK_LIVE_WINDOW (*window
);
1522 /* MINIBUF nil may or may not include minibuffers. Decide if it
1524 if (NILP (*minibuf
))
1525 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1526 else if (!EQ (*minibuf
, Qt
))
1529 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1530 => count none of them, or a specific minibuffer window (the
1531 active one) to count. */
1533 /* ALL_FRAMES nil doesn't specify which frames to include. */
1534 if (NILP (*all_frames
))
1535 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1536 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1538 else if (EQ (*all_frames
, Qvisible
))
1540 else if (XFASTINT (*all_frames
) == 0)
1542 else if (FRAMEP (*all_frames
))
1544 else if (!EQ (*all_frames
, Qt
))
1547 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1548 search just current frame, `visible' meaning search just visible
1549 frames, 0 meaning search visible and iconified frames, or a
1550 window, meaning search the frame that window belongs to, or a
1551 frame, meaning consider windows on that frame, only. */
1555 /* Return the next or previous window of WINDOW in canonical ordering
1556 of windows. NEXT_P non-zero means return the next window. See the
1557 documentation string of next-window for the meaning of MINIBUF and
1561 next_window (window
, minibuf
, all_frames
, next_p
)
1562 Lisp_Object window
, minibuf
, all_frames
;
1565 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1567 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1568 return the first window on the frame. */
1569 if (FRAMEP (all_frames
)
1570 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1571 return Fframe_first_window (all_frames
);
1577 /* Find WINDOW in the list of all windows. */
1578 list
= Fmemq (window
, window_list ());
1580 /* Scan forward from WINDOW to the end of the window list. */
1582 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1583 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1586 /* Scan from the start of the window list up to WINDOW. */
1588 for (list
= Vwindow_list
;
1589 CONSP (list
) && !EQ (XCAR (list
), window
);
1591 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1595 window
= XCAR (list
);
1599 Lisp_Object candidate
, list
;
1601 /* Scan through the list of windows for candidates. If there are
1602 candidate windows in front of WINDOW, the last one of these
1603 is the one we want. If there are candidates following WINDOW
1604 in the list, again the last one of these is the one we want. */
1606 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1608 if (EQ (XCAR (list
), window
))
1610 if (WINDOWP (candidate
))
1613 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1615 candidate
= XCAR (list
);
1618 if (WINDOWP (candidate
))
1626 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1627 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1628 If omitted, WINDOW defaults to the selected window.
1630 Optional second arg MINIBUF t means count the minibuffer window even
1631 if not active. MINIBUF nil or omitted means count the minibuffer iff
1632 it is active. MINIBUF neither t nor nil means not to count the
1633 minibuffer even if it is active.
1635 Several frames may share a single minibuffer; if the minibuffer
1636 counts, all windows on all frames that share that minibuffer count
1637 too. Therefore, `next-window' can be used to iterate through the
1638 set of windows even when the minibuffer is on another frame. If the
1639 minibuffer does not count, only windows from WINDOW's frame count.
1641 Optional third arg ALL-FRAMES t means include windows on all frames.
1642 ALL-FRAMES nil or omitted means cycle within the frames as specified
1643 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1644 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1645 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1646 Anything else means restrict to WINDOW's frame.
1648 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1649 `next-window' to iterate through the entire cycle of acceptable
1650 windows, eventually ending up back at the window you started with.
1651 `previous-window' traverses the same cycle, in the reverse order. */)
1652 (window
, minibuf
, all_frames
)
1653 Lisp_Object window
, minibuf
, all_frames
;
1655 return next_window (window
, minibuf
, all_frames
, 1);
1659 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1660 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1661 If omitted, WINDOW defaults to the selected window.
1663 Optional second arg MINIBUF t means count the minibuffer window even
1664 if not active. MINIBUF nil or omitted means count the minibuffer iff
1665 it is active. MINIBUF neither t nor nil means not to count the
1666 minibuffer even if it is active.
1668 Several frames may share a single minibuffer; if the minibuffer
1669 counts, all windows on all frames that share that minibuffer count
1670 too. Therefore, `previous-window' can be used to iterate through
1671 the set of windows even when the minibuffer is on another frame. If
1672 the minibuffer does not count, only windows from WINDOW's frame count
1674 Optional third arg ALL-FRAMES t means include windows on all frames.
1675 ALL-FRAMES nil or omitted means cycle within the frames as specified
1676 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1677 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1678 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1679 Anything else means restrict to WINDOW's frame.
1681 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1682 `previous-window' to iterate through the entire cycle of acceptable
1683 windows, eventually ending up back at the window you started with.
1684 `next-window' traverses the same cycle, in the reverse order. */)
1685 (window
, minibuf
, all_frames
)
1686 Lisp_Object window
, minibuf
, all_frames
;
1688 return next_window (window
, minibuf
, all_frames
, 0);
1692 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1693 doc
: /* Select the ARG'th different window on this frame.
1694 All windows on current frame are arranged in a cyclic order.
1695 This command selects the window ARG steps away in that order.
1696 A negative ARG moves in the opposite order. If the optional second
1697 argument ALL_FRAMES is non-nil, cycle through all frames. */)
1699 Lisp_Object arg
, all_frames
;
1705 window
= selected_window
;
1707 for (i
= XINT (arg
); i
> 0; --i
)
1708 window
= Fnext_window (window
, Qnil
, all_frames
);
1710 window
= Fprevious_window (window
, Qnil
, all_frames
);
1712 Fselect_window (window
);
1717 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1718 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1719 FRAME nil or omitted means use the selected frame.
1720 WINDOW nil or omitted means use the selected window.
1721 MINIBUF t means include the minibuffer window, even if it isn't active.
1722 MINIBUF nil or omitted means include the minibuffer window only
1724 MINIBUF neither nil nor t means never include the minibuffer window. */)
1725 (frame
, minibuf
, window
)
1726 Lisp_Object frame
, minibuf
, window
;
1729 window
= selected_window
;
1731 frame
= selected_frame
;
1733 if (!EQ (frame
, XWINDOW (window
)->frame
))
1734 error ("Window is on a different frame");
1736 return window_list_1 (window
, minibuf
, frame
);
1740 /* Return a list of windows in canonical ordering. Arguments are like
1741 for `next-window'. */
1744 window_list_1 (window
, minibuf
, all_frames
)
1745 Lisp_Object window
, minibuf
, all_frames
;
1747 Lisp_Object tail
, list
;
1749 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1752 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1753 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1754 list
= Fcons (XCAR (tail
), list
);
1756 return Fnreverse (list
);
1761 /* Look at all windows, performing an operation specified by TYPE
1763 If FRAMES is Qt, look at all frames;
1764 Qnil, look at just the selected frame;
1765 Qvisible, look at visible frames;
1766 a frame, just look at windows on that frame.
1767 If MINI is non-zero, perform the operation on minibuffer windows too. */
1772 GET_BUFFER_WINDOW
, /* Arg is buffer */
1773 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1774 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1775 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1777 UNSHOW_BUFFER
, /* Arg is buffer */
1782 window_loop (type
, obj
, mini
, frames
)
1783 enum window_loop type
;
1784 Lisp_Object obj
, frames
;
1787 Lisp_Object window
, windows
, best_window
, frame_arg
;
1789 struct gcpro gcpro1
;
1791 /* If we're only looping through windows on a particular frame,
1792 frame points to that frame. If we're looping through windows
1793 on all frames, frame is 0. */
1794 if (FRAMEP (frames
))
1795 f
= XFRAME (frames
);
1796 else if (NILP (frames
))
1797 f
= SELECTED_FRAME ();
1802 frame_arg
= Qlambda
;
1803 else if (XFASTINT (frames
) == 0)
1805 else if (EQ (frames
, Qvisible
))
1810 /* frame_arg is Qlambda to stick to one frame,
1811 Qvisible to consider all visible frames,
1814 /* Pick a window to start with. */
1818 window
= FRAME_SELECTED_WINDOW (f
);
1820 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1822 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1826 for (; CONSP (windows
); windows
= CDR (windows
))
1830 window
= XCAR (windows
);
1831 w
= XWINDOW (window
);
1833 /* Note that we do not pay attention here to whether the frame
1834 is visible, since Fwindow_list skips non-visible frames if
1835 that is desired, under the control of frame_arg. */
1836 if (!MINI_WINDOW_P (w
)
1837 /* For UNSHOW_BUFFER, we must always consider all windows. */
1838 || type
== UNSHOW_BUFFER
1839 || (mini
&& minibuf_level
> 0))
1842 case GET_BUFFER_WINDOW
:
1843 if (EQ (w
->buffer
, obj
)
1844 /* Don't find any minibuffer window
1845 except the one that is currently in use. */
1846 && (MINI_WINDOW_P (w
)
1847 ? EQ (window
, minibuf_window
)
1850 if (NILP (best_window
))
1851 best_window
= window
;
1852 else if (EQ (window
, selected_window
))
1853 /* For compatibility with 20.x, prefer to return
1855 best_window
= window
;
1859 case GET_LRU_WINDOW
:
1860 /* t as arg means consider only full-width windows */
1861 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1863 /* Ignore dedicated windows and minibuffers. */
1864 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
1866 if (NILP (best_window
)
1867 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1868 > XFASTINT (w
->use_time
)))
1869 best_window
= window
;
1872 case DELETE_OTHER_WINDOWS
:
1873 if (!EQ (window
, obj
))
1874 Fdelete_window (window
);
1877 case DELETE_BUFFER_WINDOWS
:
1878 if (EQ (w
->buffer
, obj
))
1880 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1882 /* If this window is dedicated, and in a frame of its own,
1884 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1885 && !NILP (w
->dedicated
)
1886 && other_visible_frames (f
))
1888 /* Skip the other windows on this frame.
1889 There might be one, the minibuffer! */
1890 while (CONSP (XCDR (windows
))
1891 && EQ (XWINDOW (XCAR (windows
))->frame
,
1892 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1893 windows
= XCDR (windows
);
1895 /* Now we can safely delete the frame. */
1896 Fdelete_frame (w
->frame
, Qnil
);
1898 else if (NILP (w
->parent
))
1900 /* If we're deleting the buffer displayed in the
1901 only window on the frame, find a new buffer to
1904 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1905 Fset_window_buffer (window
, buffer
);
1906 if (EQ (window
, selected_window
))
1907 Fset_buffer (w
->buffer
);
1910 Fdelete_window (window
);
1914 case GET_LARGEST_WINDOW
:
1916 /* Ignore dedicated windows and minibuffers. */
1917 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
1920 if (NILP (best_window
))
1921 best_window
= window
;
1924 struct window
*b
= XWINDOW (best_window
);
1925 if (XFASTINT (w
->height
) * XFASTINT (w
->width
)
1926 > XFASTINT (b
->height
) * XFASTINT (b
->width
))
1927 best_window
= window
;
1933 if (EQ (w
->buffer
, obj
))
1936 struct frame
*f
= XFRAME (w
->frame
);
1938 /* Find another buffer to show in this window. */
1939 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1941 /* If this window is dedicated, and in a frame of its own,
1943 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1944 && !NILP (w
->dedicated
)
1945 && other_visible_frames (f
))
1947 /* Skip the other windows on this frame.
1948 There might be one, the minibuffer! */
1949 while (CONSP (XCDR (windows
))
1950 && EQ (XWINDOW (XCAR (windows
))->frame
,
1951 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1952 windows
= XCDR (windows
);
1954 /* Now we can safely delete the frame. */
1955 Fdelete_frame (w
->frame
, Qnil
);
1957 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
1960 XSETWINDOW (window
, w
);
1961 /* If this window is dedicated and not the only window
1962 in its frame, then kill it. */
1963 Fdelete_window (window
);
1967 /* Otherwise show a different buffer in the window. */
1968 w
->dedicated
= Qnil
;
1969 Fset_window_buffer (window
, buffer
);
1970 if (EQ (window
, selected_window
))
1971 Fset_buffer (w
->buffer
);
1976 /* Check for a window that has a killed buffer. */
1977 case CHECK_ALL_WINDOWS
:
1978 if (! NILP (w
->buffer
)
1979 && NILP (XBUFFER (w
->buffer
)->name
))
1983 case WINDOW_LOOP_UNUSED
:
1992 /* Used for debugging. Abort if any window has a dead buffer. */
1995 check_all_windows ()
1997 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2000 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
2001 doc
: /* Return the window least recently selected or used for display.
2002 If optional argument FRAME is `visible', search all visible frames.
2003 If FRAME is 0, search all visible and iconified frames.
2004 If FRAME is t, search all frames.
2005 If FRAME is nil, search only the selected frame.
2006 If FRAME is a frame, search only that frame. */)
2010 register Lisp_Object w
;
2011 /* First try for a window that is full-width */
2012 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
2013 if (!NILP (w
) && !EQ (w
, selected_window
))
2015 /* If none of them, try the rest */
2016 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
2019 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
2020 doc
: /* Return the largest window in area.
2021 If optional argument FRAME is `visible', search all visible frames.
2022 If FRAME is 0, search all visible and iconified frames.
2023 If FRAME is t, search all frames.
2024 If FRAME is nil, search only the selected frame.
2025 If FRAME is a frame, search only that frame. */)
2029 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
2033 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2034 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2035 If optional argument FRAME is `visible', search all visible frames.
2036 If optional argument FRAME is 0, search all visible and iconified frames.
2037 If FRAME is t, search all frames.
2038 If FRAME is nil, search only the selected frame.
2039 If FRAME is a frame, search only that frame. */)
2041 Lisp_Object buffer
, frame
;
2043 buffer
= Fget_buffer (buffer
);
2044 if (BUFFERP (buffer
))
2045 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2050 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2052 doc
: /* Make WINDOW (or the selected window) fill its frame.
2053 Only the frame WINDOW is on is affected.
2054 This function tries to reduce display jumps
2055 by keeping the text previously visible in WINDOW
2056 in the same place on the frame. Doing this depends on
2057 the value of (window-start WINDOW), so if calling this function
2058 in a program gives strange scrolling, make sure the window-start
2059 value is reasonable when this function is called. */)
2068 window
= selected_window
;
2070 CHECK_LIVE_WINDOW (window
);
2071 w
= XWINDOW (window
);
2073 startpos
= marker_position (w
->start
);
2074 top
= XFASTINT (w
->top
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2076 if (MINI_WINDOW_P (w
) && top
> 0)
2077 error ("Can't expand minibuffer to full frame");
2079 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2081 /* Try to minimize scrolling, by setting the window start to the point
2082 will cause the text at the old window start to be at the same place
2083 on the frame. But don't try to do this if the window start is
2084 outside the visible portion (as might happen when the display is
2085 not current, due to typeahead). */
2086 new_top
= XFASTINT (w
->top
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2088 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2089 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2091 struct position pos
;
2092 struct buffer
*obuf
= current_buffer
;
2094 Fset_buffer (w
->buffer
);
2095 /* This computation used to temporarily move point, but that can
2096 have unwanted side effects due to text properties. */
2097 pos
= *vmotion (startpos
, -top
, w
);
2099 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2100 w
->window_end_valid
= Qnil
;
2101 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2102 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2104 /* We need to do this, so that the window-scroll-functions
2106 w
->optional_new_start
= Qt
;
2108 set_buffer_internal (obuf
);
2114 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2115 1, 2, "bDelete windows on (buffer): ",
2116 doc
: /* Delete all windows showing BUFFER.
2117 Optional second argument FRAME controls which frames are affected.
2118 If optional argument FRAME is `visible', search all visible frames.
2119 If FRAME is 0, search all visible and iconified frames.
2120 If FRAME is nil, search all frames.
2121 If FRAME is t, search only the selected frame.
2122 If FRAME is a frame, search only that frame. */)
2124 Lisp_Object buffer
, frame
;
2126 /* FRAME uses t and nil to mean the opposite of what window_loop
2130 else if (EQ (frame
, Qt
))
2135 buffer
= Fget_buffer (buffer
);
2136 CHECK_BUFFER (buffer
);
2137 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2143 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2144 Sreplace_buffer_in_windows
,
2145 1, 1, "bReplace buffer in windows: ",
2146 doc
: /* Replace BUFFER with some other buffer in all windows showing it. */)
2152 buffer
= Fget_buffer (buffer
);
2153 CHECK_BUFFER (buffer
);
2154 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2159 /* Replace BUFFER with some other buffer in all windows
2160 of all frames, even those on other keyboards. */
2163 replace_buffer_in_all_windows (buffer
)
2167 Lisp_Object tail
, frame
;
2169 /* A single call to window_loop won't do the job
2170 because it only considers frames on the current keyboard.
2171 So loop manually over frames, and handle each one. */
2172 FOR_EACH_FRAME (tail
, frame
)
2173 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2175 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2179 /* Set the height of WINDOW and all its inferiors. */
2181 /* The smallest acceptable dimensions for a window. Anything smaller
2182 might crash Emacs. */
2184 #define MIN_SAFE_WINDOW_WIDTH (2)
2185 #define MIN_SAFE_WINDOW_HEIGHT (1)
2187 /* Make sure that window_min_height and window_min_width are
2188 not too small; if they are, set them to safe minima. */
2191 check_min_window_sizes ()
2193 /* Smaller values might permit a crash. */
2194 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2195 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2196 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2197 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2200 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2201 minimum allowable size. */
2204 check_frame_size (frame
, rows
, cols
)
2208 /* For height, we have to see:
2209 how many windows the frame has at minimum (one or two),
2210 and whether it has a menu bar or other special stuff at the top. */
2212 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2213 ? MIN_SAFE_WINDOW_HEIGHT
2214 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2216 if (FRAME_TOP_MARGIN (frame
) > 0)
2217 min_height
+= FRAME_TOP_MARGIN (frame
);
2219 if (*rows
< min_height
)
2221 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2222 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2226 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2227 check if W's width can be changed, otherwise check W's height.
2228 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2229 siblings, too. If none of the siblings is resizable, WINDOW isn't
2233 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2235 int width_p
, check_siblings_p
;
2240 if (!NILP (w
->hchild
))
2242 c
= XWINDOW (w
->hchild
);
2246 /* A horiz. combination is fixed-width if all of if its
2248 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2249 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2250 fixed_p
= c
== NULL
;
2254 /* A horiz. combination is fixed-height if one of if its
2256 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2257 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2258 fixed_p
= c
!= NULL
;
2261 else if (!NILP (w
->vchild
))
2263 c
= XWINDOW (w
->vchild
);
2267 /* A vert. combination is fixed-width if one of if its
2269 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2270 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2271 fixed_p
= c
!= NULL
;
2275 /* A vert. combination is fixed-height if all of if its
2277 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2278 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2279 fixed_p
= c
== NULL
;
2282 else if (BUFFERP (w
->buffer
))
2284 if (w
->height_fixed_p
&& !width_p
)
2288 struct buffer
*old
= current_buffer
;
2291 current_buffer
= XBUFFER (w
->buffer
);
2292 val
= find_symbol_value (Qwindow_size_fixed
);
2293 current_buffer
= old
;
2296 if (!EQ (val
, Qunbound
))
2298 fixed_p
= !NILP (val
);
2301 && ((EQ (val
, Qheight
) && width_p
)
2302 || (EQ (val
, Qwidth
) && !width_p
)))
2307 /* Can't tell if this one is resizable without looking at
2308 siblings. If all siblings are fixed-size this one is too. */
2309 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2313 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2314 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2318 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2319 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2333 /* Return the minimum size of window W, not taking fixed-width windows
2334 into account. WIDTH_P non-zero means return the minimum width,
2335 otherwise return the minimum height. If W is a combination window,
2336 compute the minimum size from the minimum sizes of W's children. */
2339 window_min_size_1 (w
, width_p
)
2346 if (!NILP (w
->hchild
))
2348 c
= XWINDOW (w
->hchild
);
2353 /* The min width of a horizontal combination is
2354 the sum of the min widths of its children. */
2357 size
+= window_min_size_1 (c
, width_p
);
2358 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2363 /* The min height a horizontal combination equals
2364 the maximum of all min height of its children. */
2367 int min_size
= window_min_size_1 (c
, width_p
);
2368 size
= max (min_size
, size
);
2369 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2373 else if (!NILP (w
->vchild
))
2375 c
= XWINDOW (w
->vchild
);
2380 /* The min width of a vertical combination is
2381 the maximum of the min widths of its children. */
2384 int min_size
= window_min_size_1 (c
, width_p
);
2385 size
= max (min_size
, size
);
2386 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2391 /* The min height of a vertical combination equals
2392 the sum of the min height of its children. */
2395 size
+= window_min_size_1 (c
, width_p
);
2396 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2403 size
= window_min_width
;
2406 if (MINI_WINDOW_P (w
)
2407 || (!WINDOW_WANTS_MODELINE_P (w
)
2408 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2411 size
= window_min_height
;
2419 /* Return the minimum size of window W, taking fixed-size windows into
2420 account. WIDTH_P non-zero means return the minimum width,
2421 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2422 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2423 unless FIXED is null. */
2426 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2428 int width_p
, ignore_fixed_p
, *fixed
;
2435 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2441 size
= width_p
? XFASTINT (w
->width
) : XFASTINT (w
->height
);
2443 size
= window_min_size_1 (w
, width_p
);
2449 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2450 WINDOW's width. Resize WINDOW's children, if any, so that they
2451 keep their proportionate size relative to WINDOW. Propagate
2452 WINDOW's top or left edge position to children. Delete windows
2453 that become too small unless NODELETE_P is non-zero.
2455 If NODELETE_P is 2, that means we do delete windows that are
2456 too small, even if they were too small before! */
2459 size_window (window
, size
, width_p
, nodelete_p
)
2461 int size
, width_p
, nodelete_p
;
2463 struct window
*w
= XWINDOW (window
);
2465 Lisp_Object child
, *forward
, *sideward
;
2466 int old_size
, min_size
;
2468 if (nodelete_p
== 2)
2471 check_min_window_sizes ();
2472 size
= max (0, size
);
2474 /* If the window has been "too small" at one point,
2475 don't delete it for being "too small" in the future.
2476 Preserve it as long as that is at all possible. */
2479 old_size
= XINT (w
->width
);
2480 min_size
= window_min_width
;
2484 old_size
= XINT (w
->height
);
2485 min_size
= window_min_height
;
2488 if (old_size
< min_size
&& nodelete_p
!= 2)
2489 w
->too_small_ok
= Qt
;
2491 /* Maybe delete WINDOW if it's too small. */
2492 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2494 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2495 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2497 min_size
= width_p
? window_min_width
: window_min_height
;
2499 if (size
< min_size
)
2501 delete_window (window
);
2506 /* Set redisplay hints. */
2507 w
->last_modified
= make_number (0);
2508 w
->last_overlay_modified
= make_number (0);
2509 windows_or_buffers_changed
++;
2510 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2514 sideward
= &w
->vchild
;
2515 forward
= &w
->hchild
;
2516 w
->width
= make_number (size
);
2520 sideward
= &w
->hchild
;
2521 forward
= &w
->vchild
;
2522 w
->height
= make_number (size
);
2523 w
->orig_height
= Qnil
;
2526 if (!NILP (*sideward
))
2528 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2530 c
= XWINDOW (child
);
2535 size_window (child
, size
, width_p
, nodelete_p
);
2538 else if (!NILP (*forward
))
2540 int fixed_size
, each
, extra
, n
;
2541 int resize_fixed_p
, nfixed
;
2542 int last_pos
, first_pos
, nchildren
, total
;
2544 /* Determine the fixed-size portion of the this window, and the
2545 number of child windows. */
2546 fixed_size
= nchildren
= nfixed
= total
= 0;
2547 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2551 c
= XWINDOW (child
);
2552 child_size
= width_p
? XINT (c
->width
) : XINT (c
->height
);
2553 total
+= child_size
;
2555 if (window_fixed_size_p (c
, width_p
, 0))
2557 fixed_size
+= child_size
;
2562 /* If the new size is smaller than fixed_size, or if there
2563 aren't any resizable windows, allow resizing fixed-size
2565 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2567 /* Compute how many lines/columns to add to each child. The
2568 value of extra takes care of rounding errors. */
2569 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2570 each
= (size
- total
) / n
;
2571 extra
= (size
- total
) - n
* each
;
2573 /* Compute new children heights and edge positions. */
2574 first_pos
= width_p
? XINT (w
->left
) : XINT (w
->top
);
2575 last_pos
= first_pos
;
2576 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2578 int new_size
, old_size
;
2580 c
= XWINDOW (child
);
2581 old_size
= width_p
? XFASTINT (c
->width
) : XFASTINT (c
->height
);
2582 new_size
= old_size
;
2584 /* The top or left edge position of this child equals the
2585 bottom or right edge of its predecessor. */
2587 c
->left
= make_number (last_pos
);
2589 c
->top
= make_number (last_pos
);
2591 /* If this child can be resized, do it. */
2592 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2594 new_size
= old_size
+ each
+ extra
;
2598 /* Set new height. Note that size_window also propagates
2599 edge positions to children, so it's not a no-op if we
2600 didn't change the child's size. */
2601 size_window (child
, new_size
, width_p
, 1);
2603 /* Remember the bottom/right edge position of this child; it
2604 will be used to set the top/left edge of the next child. */
2605 last_pos
+= new_size
;
2608 /* We should have covered the parent exactly with child windows. */
2609 xassert (size
== last_pos
- first_pos
);
2611 /* Now delete any children that became too small. */
2613 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2616 c
= XWINDOW (child
);
2617 child_size
= width_p
? XINT (c
->width
) : XINT (c
->height
);
2618 size_window (child
, child_size
, width_p
, 2);
2623 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2624 WINDOW's children. NODELETE non-zero means don't delete windows
2625 that become too small in the process. (The caller should check
2626 later and do so if appropriate.) */
2629 set_window_height (window
, height
, nodelete
)
2634 size_window (window
, height
, 0, nodelete
);
2638 /* Set WINDOW's width to WIDTH, and recursively change the width of
2639 WINDOW's children. NODELETE non-zero means don't delete windows
2640 that become too small in the process. (The caller should check
2641 later and do so if appropriate.) */
2644 set_window_width (window
, width
, nodelete
)
2649 size_window (window
, width
, 1, nodelete
);
2653 int window_select_count
;
2656 Fset_window_buffer_unwind (obuf
)
2664 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2665 means it's allowed to run hooks. See make_frame for a case where
2666 it's not allowed. */
2669 set_window_buffer (window
, buffer
, run_hooks_p
)
2670 Lisp_Object window
, buffer
;
2673 struct window
*w
= XWINDOW (window
);
2674 struct buffer
*b
= XBUFFER (buffer
);
2675 int count
= SPECPDL_INDEX ();
2679 if (EQ (window
, selected_window
))
2680 b
->last_selected_window
= window
;
2682 /* Update time stamps of buffer display. */
2683 if (INTEGERP (b
->display_count
))
2684 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
2685 b
->display_time
= Fcurrent_time ();
2687 XSETFASTINT (w
->window_end_pos
, 0);
2688 XSETFASTINT (w
->window_end_vpos
, 0);
2689 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
2690 w
->window_end_valid
= Qnil
;
2691 w
->hscroll
= w
->min_hscroll
= make_number (0);
2693 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
2694 set_marker_restricted (w
->start
,
2695 make_number (b
->last_window_start
),
2697 w
->start_at_line_beg
= Qnil
;
2698 w
->force_start
= Qnil
;
2699 XSETFASTINT (w
->last_modified
, 0);
2700 XSETFASTINT (w
->last_overlay_modified
, 0);
2701 windows_or_buffers_changed
++;
2703 /* We must select BUFFER for running the window-scroll-functions.
2704 If WINDOW is selected, switch permanently.
2705 Otherwise, switch but go back to the ambient buffer afterward. */
2706 if (EQ (window
, selected_window
))
2707 Fset_buffer (buffer
);
2708 /* We can't check ! NILP (Vwindow_scroll_functions) here
2709 because that might itself be a local variable. */
2710 else if (window_initialized
)
2712 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
2713 Fset_buffer (buffer
);
2716 /* Set left and right marginal area width from buffer. */
2717 Fset_window_margins (window
, b
->left_margin_width
, b
->right_margin_width
);
2721 if (! NILP (Vwindow_scroll_functions
))
2722 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2723 Fmarker_position (w
->start
));
2725 if (! NILP (Vwindow_configuration_change_hook
)
2726 && ! NILP (Vrun_hooks
))
2727 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
2730 unbind_to (count
, Qnil
);
2734 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
2735 doc
: /* Make WINDOW display BUFFER as its contents.
2736 BUFFER can be a buffer or buffer name. */)
2738 register Lisp_Object window
, buffer
;
2740 register Lisp_Object tem
;
2741 register struct window
*w
= decode_window (window
);
2743 XSETWINDOW (window
, w
);
2744 buffer
= Fget_buffer (buffer
);
2745 CHECK_BUFFER (buffer
);
2747 if (NILP (XBUFFER (buffer
)->name
))
2748 error ("Attempt to display deleted buffer");
2752 error ("Window is deleted");
2753 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
2754 is first being set up. */
2756 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
2757 error ("Window is dedicated to `%s'",
2758 SDATA (XBUFFER (tem
)->name
));
2763 set_window_buffer (window
, buffer
, 1);
2767 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
2768 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
2769 If WINDOW is not already selected, also make WINDOW's buffer current.
2770 Also make WINDOW the frame's selected window.
2772 Note that the main editor command loop
2773 selects the buffer of the selected window before each command. */)
2775 register Lisp_Object window
;
2777 return select_window_1 (window
, 1);
2780 /* Note that selected_window can be nil
2781 when this is called from Fset_window_configuration. */
2784 select_window_1 (window
, recordflag
)
2785 register Lisp_Object window
;
2788 register struct window
*w
;
2789 register struct window
*ow
;
2792 CHECK_LIVE_WINDOW (window
);
2794 w
= XWINDOW (window
);
2795 w
->frozen_window_start_p
= 0;
2797 XSETFASTINT (w
->use_time
, ++window_select_count
);
2798 if (EQ (window
, selected_window
))
2801 if (!NILP (selected_window
))
2803 ow
= XWINDOW (selected_window
);
2804 if (! NILP (ow
->buffer
))
2805 set_marker_both (ow
->pointm
, ow
->buffer
,
2806 BUF_PT (XBUFFER (ow
->buffer
)),
2807 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
2810 selected_window
= window
;
2811 sf
= SELECTED_FRAME ();
2812 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
2814 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
2815 /* Use this rather than Fhandle_switch_frame
2816 so that FRAME_FOCUS_FRAME is moved appropriately as we
2817 move around in the state where a minibuffer in a separate
2819 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
2822 sf
->selected_window
= window
;
2825 record_buffer (w
->buffer
);
2826 Fset_buffer (w
->buffer
);
2828 XBUFFER (w
->buffer
)->last_selected_window
= window
;
2830 /* Go to the point recorded in the window.
2831 This is important when the buffer is in more
2832 than one window. It also matters when
2833 redisplay_window has altered point after scrolling,
2834 because it makes the change only in the window. */
2836 register int new_point
= marker_position (w
->pointm
);
2837 if (new_point
< BEGV
)
2839 else if (new_point
> ZV
)
2845 windows_or_buffers_changed
++;
2849 /* Deiconify the frame containing the window WINDOW,
2850 unless it is the selected frame;
2853 The reason for the exception for the selected frame
2854 is that it seems better not to change the selected frames visibility
2855 merely because of displaying a different buffer in it.
2856 The deiconification is useful when a buffer gets shown in
2857 another frame that you were not using lately. */
2860 display_buffer_1 (window
)
2863 Lisp_Object frame
= XWINDOW (window
)->frame
;
2864 FRAME_PTR f
= XFRAME (frame
);
2866 FRAME_SAMPLE_VISIBILITY (f
);
2868 if (!EQ (frame
, selected_frame
))
2870 if (FRAME_ICONIFIED_P (f
))
2871 Fmake_frame_visible (frame
);
2872 else if (FRAME_VISIBLE_P (f
))
2873 Fraise_frame (frame
);
2879 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
2880 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would be created specially.
2881 The value is actually t if the frame should be called with default frame
2882 parameters, and a list of frame parameters if they were specified.
2883 See `special-display-buffer-names', and `special-display-regexps'. */)
2885 Lisp_Object buffer_name
;
2889 CHECK_STRING (buffer_name
);
2891 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
2895 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
2899 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2901 Lisp_Object car
= XCAR (tem
);
2903 && fast_string_match (car
, buffer_name
) >= 0)
2905 else if (CONSP (car
)
2906 && STRINGP (XCAR (car
))
2907 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2913 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
2914 doc
: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
2915 See `same-window-buffer-names' and `same-window-regexps'. */)
2917 Lisp_Object buffer_name
;
2921 CHECK_STRING (buffer_name
);
2923 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
2927 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
2931 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2933 Lisp_Object car
= XCAR (tem
);
2935 && fast_string_match (car
, buffer_name
) >= 0)
2937 else if (CONSP (car
)
2938 && STRINGP (XCAR (car
))
2939 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2945 /* Use B so the default is (other-buffer). */
2946 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
2947 "BDisplay buffer: \nP",
2948 doc
: /* Make BUFFER appear in some window but don't select it.
2949 BUFFER can be a buffer or a buffer name.
2950 If BUFFER is shown already in some window, just use that one,
2951 unless the window is the selected window and the optional second
2952 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
2953 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
2954 Returns the window displaying BUFFER.
2955 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
2956 displaying BUFFER, then simply raise that frame.
2958 The variables `special-display-buffer-names', `special-display-regexps',
2959 `same-window-buffer-names', and `same-window-regexps' customize how certain
2960 buffer names are handled.
2962 If optional argument FRAME is `visible', search all visible frames.
2963 If FRAME is 0, search all visible and iconified frames.
2964 If FRAME is t, search all frames.
2965 If FRAME is a frame, search only that frame.
2966 If FRAME is nil, search only the selected frame
2967 (actually the last nonminibuffer frame),
2968 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
2969 which means search visible and iconified frames.
2971 If `even-window-heights' is non-nil, window heights will be evened out
2972 if displaying the buffer causes two vertically adjacent windows to be
2974 (buffer
, not_this_window
, frame
)
2975 register Lisp_Object buffer
, not_this_window
, frame
;
2977 register Lisp_Object window
, tem
, swp
;
2981 buffer
= Fget_buffer (buffer
);
2982 CHECK_BUFFER (buffer
);
2984 if (!NILP (Vdisplay_buffer_function
))
2985 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
2987 if (NILP (not_this_window
)
2988 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
2989 return display_buffer_1 (selected_window
);
2991 /* See if the user has specified this buffer should appear
2992 in the selected window. */
2993 if (NILP (not_this_window
))
2995 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
2996 if (!NILP (swp
) && !no_switch_window (selected_window
))
2998 Fswitch_to_buffer (buffer
, Qnil
);
2999 return display_buffer_1 (selected_window
);
3003 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3004 look for a window showing BUFFER on any visible or iconified frame.
3005 Otherwise search only the current frame. */
3008 else if (pop_up_frames
3009 || display_buffer_reuse_frames
3010 || last_nonminibuf_frame
== 0)
3011 XSETFASTINT (tem
, 0);
3013 XSETFRAME (tem
, last_nonminibuf_frame
);
3015 window
= Fget_buffer_window (buffer
, tem
);
3017 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3018 return display_buffer_1 (window
);
3020 /* Certain buffer names get special handling. */
3021 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3023 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3025 return call1 (Vspecial_display_function
, buffer
);
3027 return call2 (Vspecial_display_function
, buffer
, tem
);
3030 /* If there are no frames open that have more than a minibuffer,
3031 we need to create a new frame. */
3032 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3034 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3035 Fset_window_buffer (window
, buffer
);
3036 return display_buffer_1 (window
);
3039 f
= SELECTED_FRAME ();
3041 || FRAME_MINIBUF_ONLY_P (f
)
3042 /* If the current frame is a special display frame,
3043 don't try to reuse its windows. */
3044 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3049 if (FRAME_MINIBUF_ONLY_P (f
))
3050 XSETFRAME (frames
, last_nonminibuf_frame
);
3051 /* Don't try to create a window if we would get an error. */
3052 if (split_height_threshold
< window_min_height
<< 1)
3053 split_height_threshold
= window_min_height
<< 1;
3055 /* Note that both Fget_largest_window and Fget_lru_window
3056 ignore minibuffers and dedicated windows.
3057 This means they can return nil. */
3059 /* If the frame we would try to split cannot be split,
3060 try other frames. */
3061 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3063 /* Try visible frames first. */
3064 window
= Fget_largest_window (Qvisible
);
3065 /* If that didn't work, try iconified frames. */
3067 window
= Fget_largest_window (make_number (0));
3069 window
= Fget_largest_window (Qt
);
3072 window
= Fget_largest_window (frames
);
3074 /* If we got a tall enough full-width window that can be split,
3077 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3078 && window_height (window
) >= split_height_threshold
3079 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3080 window
= Fsplit_window (window
, Qnil
, Qnil
);
3083 Lisp_Object upper
, lower
, other
;
3085 window
= Fget_lru_window (frames
);
3086 /* If the LRU window is selected, and big enough,
3087 and can be split, split it. */
3089 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3090 && (EQ (window
, selected_window
)
3091 || EQ (XWINDOW (window
)->parent
, Qnil
))
3092 && window_height (window
) >= window_min_height
<< 1)
3093 window
= Fsplit_window (window
, Qnil
, Qnil
);
3094 /* If Fget_lru_window returned nil, try other approaches. */
3096 /* Try visible frames first. */
3098 window
= Fget_buffer_window (buffer
, Qvisible
);
3100 window
= Fget_largest_window (Qvisible
);
3101 /* If that didn't work, try iconified frames. */
3103 window
= Fget_buffer_window (buffer
, make_number (0));
3105 window
= Fget_largest_window (make_number (0));
3106 /* Try invisible frames. */
3108 window
= Fget_buffer_window (buffer
, Qt
);
3110 window
= Fget_largest_window (Qt
);
3111 /* As a last resort, make a new frame. */
3113 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3114 /* If window appears above or below another,
3115 even out their heights. */
3116 other
= upper
= lower
= Qnil
;
3117 if (!NILP (XWINDOW (window
)->prev
))
3118 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3119 if (!NILP (XWINDOW (window
)->next
))
3120 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3122 && !NILP (Veven_window_heights
)
3123 /* Check that OTHER and WINDOW are vertically arrayed. */
3124 && !EQ (XWINDOW (other
)->top
, XWINDOW (window
)->top
)
3125 && (XFASTINT (XWINDOW (other
)->height
)
3126 > XFASTINT (XWINDOW (window
)->height
)))
3128 int total
= (XFASTINT (XWINDOW (other
)->height
)
3129 + XFASTINT (XWINDOW (window
)->height
));
3130 enlarge_window (upper
,
3131 total
/ 2 - XFASTINT (XWINDOW (upper
)->height
),
3137 window
= Fget_lru_window (Qnil
);
3139 Fset_window_buffer (window
, buffer
);
3140 return display_buffer_1 (window
);
3144 temp_output_buffer_show (buf
)
3145 register Lisp_Object buf
;
3147 register struct buffer
*old
= current_buffer
;
3148 register Lisp_Object window
;
3149 register struct window
*w
;
3151 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3154 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3158 #if 0 /* rms: there should be no reason for this. */
3159 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3161 set_buffer_internal (old
);
3163 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3164 call1 (Vtemp_buffer_show_function
, buf
);
3167 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3169 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3170 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3171 Vminibuf_scroll_window
= window
;
3172 w
= XWINDOW (window
);
3173 XSETFASTINT (w
->hscroll
, 0);
3174 XSETFASTINT (w
->min_hscroll
, 0);
3175 set_marker_restricted_both (w
->start
, buf
, 1, 1);
3176 set_marker_restricted_both (w
->pointm
, buf
, 1, 1);
3178 /* Run temp-buffer-show-hook, with the chosen window selected
3179 and its buffer current. */
3180 if (!NILP (Vrun_hooks
))
3183 tem
= Fboundp (Qtemp_buffer_show_hook
);
3186 tem
= Fsymbol_value (Qtemp_buffer_show_hook
);
3189 int count
= SPECPDL_INDEX ();
3190 Lisp_Object prev_window
;
3191 prev_window
= selected_window
;
3193 /* Select the window that was chosen, for running the hook. */
3194 /* Both this Fselect_window and the select_window_1
3195 below will (may) incorrectly set-buffer to the buffer
3196 displayed in the window. --stef */
3197 record_unwind_protect (Fselect_window
, prev_window
);
3198 select_window_1 (window
, 0);
3199 Fset_buffer (w
->buffer
);
3200 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3201 select_window_1 (prev_window
, 0);
3202 unbind_to (count
, Qnil
);
3210 make_dummy_parent (window
)
3214 register struct window
*o
, *p
;
3217 o
= XWINDOW (window
);
3218 p
= allocate_window ();
3219 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3220 ((struct Lisp_Vector
*) p
)->contents
[i
]
3221 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3222 XSETWINDOW (new, p
);
3224 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
3226 /* Put new into window structure in place of window */
3227 replace_window (window
, new);
3240 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3241 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3242 WINDOW defaults to selected one and SIZE to half its size.
3243 If optional third arg HORFLAG is non-nil, split side by side
3244 and put SIZE columns in the first of the pair. In that case,
3245 SIZE includes that window's scroll bar, or the divider column to its right. */)
3246 (window
, size
, horflag
)
3247 Lisp_Object window
, size
, horflag
;
3249 register Lisp_Object
new;
3250 register struct window
*o
, *p
;
3252 register int size_int
;
3255 window
= selected_window
;
3257 CHECK_LIVE_WINDOW (window
);
3259 o
= XWINDOW (window
);
3260 fo
= XFRAME (WINDOW_FRAME (o
));
3264 if (!NILP (horflag
))
3265 /* Calculate the size of the left-hand window, by dividing
3266 the usable space in columns by two.
3267 We round up, since the left-hand window may include
3268 a dividing line, while the right-hand may not. */
3269 size_int
= (XFASTINT (o
->width
) + 1) >> 1;
3271 size_int
= XFASTINT (o
->height
) >> 1;
3275 CHECK_NUMBER (size
);
3276 size_int
= XINT (size
);
3279 if (MINI_WINDOW_P (o
))
3280 error ("Attempt to split minibuffer window");
3281 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3282 error ("Attempt to split fixed-size window");
3284 check_min_window_sizes ();
3288 if (size_int
< window_min_height
)
3289 error ("Window height %d too small (after splitting)", size_int
);
3290 if (size_int
+ window_min_height
> XFASTINT (o
->height
))
3291 error ("Window height %d too small (after splitting)",
3292 XFASTINT (o
->height
) - size_int
);
3293 if (NILP (o
->parent
)
3294 || NILP (XWINDOW (o
->parent
)->vchild
))
3296 make_dummy_parent (window
);
3298 XWINDOW (new)->vchild
= window
;
3303 if (size_int
< window_min_width
)
3304 error ("Window width %d too small (after splitting)", size_int
);
3306 if (size_int
+ window_min_width
> XFASTINT (o
->width
))
3307 error ("Window width %d too small (after splitting)",
3308 XFASTINT (o
->width
) - size_int
);
3309 if (NILP (o
->parent
)
3310 || NILP (XWINDOW (o
->parent
)->hchild
))
3312 make_dummy_parent (window
);
3314 XWINDOW (new)->hchild
= window
;
3318 /* Now we know that window's parent is a vertical combination
3319 if we are dividing vertically, or a horizontal combination
3320 if we are making side-by-side windows */
3322 windows_or_buffers_changed
++;
3323 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3324 new = make_window ();
3327 p
->frame
= o
->frame
;
3329 if (!NILP (p
->next
))
3330 XWINDOW (p
->next
)->prev
= new;
3333 p
->parent
= o
->parent
;
3335 p
->window_end_valid
= Qnil
;
3336 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3338 /* Apportion the available frame space among the two new windows */
3340 if (!NILP (horflag
))
3342 p
->height
= o
->height
;
3344 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size_int
);
3345 XSETFASTINT (o
->width
, size_int
);
3346 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size_int
);
3351 p
->width
= o
->width
;
3352 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size_int
);
3353 XSETFASTINT (o
->height
, size_int
);
3354 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size_int
);
3357 /* Adjust glyph matrices. */
3359 Fset_window_buffer (new, o
->buffer
);
3363 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 3, "p",
3364 doc
: /* Make current window ARG lines bigger.
3365 From program, optional second arg non-nil means grow sideways ARG columns.
3366 Interactively, if an argument is not given, make the window one line bigger.
3368 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3369 of the siblings above or to the left of the selected window. Only
3370 siblings to the right or below are changed. */)
3371 (arg
, side
, preserve_before
)
3372 register Lisp_Object arg
, side
, preserve_before
;
3375 enlarge_window (selected_window
, XINT (arg
), !NILP (side
),
3376 !NILP (preserve_before
));
3378 if (! NILP (Vwindow_configuration_change_hook
))
3379 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3384 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3385 doc
: /* Make current window ARG lines smaller.
3386 From program, optional second arg non-nil means shrink sideways arg columns.
3387 Interactively, if an argument is not given, make the window one line smaller.
3389 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3390 of the siblings above or to the left of the selected window. Only
3391 siblings to the right or below are changed. */)
3392 (arg
, side
, preserve_before
)
3393 register Lisp_Object arg
, side
, preserve_before
;
3396 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3397 !NILP (preserve_before
));
3399 if (! NILP (Vwindow_configuration_change_hook
))
3400 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3406 window_height (window
)
3409 register struct window
*p
= XWINDOW (window
);
3410 return XFASTINT (p
->height
);
3414 window_width (window
)
3417 register struct window
*p
= XWINDOW (window
);
3418 return XFASTINT (p
->width
);
3423 *(widthflag ? &(XWINDOW (w)->left) : &(XWINDOW (w)->top))
3425 #define CURSIZE(w) \
3426 *(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
3429 /* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
3430 increase its width. Siblings of the selected window are resized to
3431 fulfill the size request. If they become too small in the process,
3432 they will be deleted.
3434 If PRESERVE_BEFORE is nonzero, that means don't alter
3435 the siblings to the left or above WINDOW. */
3438 enlarge_window (window
, delta
, widthflag
, preserve_before
)
3440 int delta
, widthflag
, preserve_before
;
3442 Lisp_Object parent
, next
, prev
;
3446 int (*sizefun
) P_ ((Lisp_Object
))
3447 = widthflag
? window_width
: window_height
;
3448 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3449 = (widthflag
? set_window_width
: set_window_height
);
3451 /* Check values of window_min_width and window_min_height for
3453 check_min_window_sizes ();
3455 /* Give up if this window cannot be resized. */
3456 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3457 error ("Window is not resizable");
3459 /* Find the parent of the selected window. */
3462 p
= XWINDOW (window
);
3468 error ("No other window to side of this one");
3473 ? !NILP (XWINDOW (parent
)->hchild
)
3474 : !NILP (XWINDOW (parent
)->vchild
))
3480 sizep
= &CURSIZE (window
);
3483 register int maxdelta
;
3485 /* Compute the maximum size increment this window can have. */
3487 if (preserve_before
)
3491 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
3492 /* Subtract size of siblings before, since we can't take that. */
3493 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
3496 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3497 - window_min_size (XWINDOW (p
->next
),
3502 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3503 /* This is a main window followed by a minibuffer. */
3504 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3505 - window_min_size (XWINDOW (p
->next
),
3507 /* This is a minibuffer following a main window. */
3508 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3509 - window_min_size (XWINDOW (p
->prev
),
3511 /* This is a frame with only one window, a minibuffer-only
3512 or a minibufferless frame. */
3515 if (delta
> maxdelta
)
3516 /* This case traps trying to make the minibuffer
3517 the full frame, or make the only window aside from the
3518 minibuffer the full frame. */
3522 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3524 delete_window (window
);
3531 /* Find the total we can get from other siblings without deleting them. */
3533 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3534 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3536 if (! preserve_before
)
3537 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3538 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3541 /* If we can get it all from them without deleting them, do so. */
3542 if (delta
<= maximum
)
3544 Lisp_Object first_unaffected
;
3545 Lisp_Object first_affected
;
3550 first_affected
= window
;
3551 /* Look at one sibling at a time,
3552 moving away from this window in both directions alternately,
3553 and take as much as we can get without deleting that sibling. */
3555 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
3559 int this_one
= ((*sizefun
) (next
)
3560 - window_min_size (XWINDOW (next
),
3561 widthflag
, 0, &fixed_p
));
3564 if (this_one
> delta
)
3567 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
3568 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3573 next
= XWINDOW (next
)->next
;
3579 if (!preserve_before
&& ! NILP (prev
))
3581 int this_one
= ((*sizefun
) (prev
)
3582 - window_min_size (XWINDOW (prev
),
3583 widthflag
, 0, &fixed_p
));
3586 if (this_one
> delta
)
3589 first_affected
= prev
;
3591 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
3592 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3597 prev
= XWINDOW (prev
)->prev
;
3601 xassert (delta
== 0);
3603 /* Now recalculate the edge positions of all the windows affected,
3604 based on the new sizes. */
3605 first_unaffected
= next
;
3606 prev
= first_affected
;
3607 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
3608 prev
= next
, next
= XWINDOW (next
)->next
)
3610 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
3611 /* This does not change size of NEXT,
3612 but it propagates the new top edge to its children */
3613 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
3618 register int delta1
;
3619 register int opht
= (*sizefun
) (parent
);
3621 if (opht
<= XINT (*sizep
) + delta
)
3623 /* If trying to grow this window to or beyond size of the parent,
3624 just delete all the sibling windows. */
3625 Lisp_Object start
, tem
, next
;
3627 start
= XWINDOW (parent
)->vchild
;
3629 start
= XWINDOW (parent
)->hchild
;
3631 /* Delete any siblings that come after WINDOW. */
3632 tem
= XWINDOW (window
)->next
;
3633 while (! NILP (tem
))
3635 next
= XWINDOW (tem
)->next
;
3636 delete_window (tem
);
3640 /* Delete any siblings that come after WINDOW.
3641 Note that if START is not WINDOW, then WINDOW still
3642 Fhas siblings, so WINDOW has not yet replaced its parent. */
3644 while (! EQ (tem
, window
))
3646 next
= XWINDOW (tem
)->next
;
3647 delete_window (tem
);
3653 /* Otherwise, make delta1 just right so that if we add
3654 delta1 lines to this window and to the parent, and then
3655 shrink the parent back to its original size, the new
3656 proportional size of this window will increase by delta.
3658 The function size_window will compute the new height h'
3659 of the window from delta1 as:
3662 x = delta1 - delta1/n * n for the 1st resizable child
3665 where n is the number of children that can be resized.
3666 We can ignore x by choosing a delta1 that is a multiple of
3667 n. We want the height of this window to come out as
3677 The number of children n equals the number of resizable
3678 children of this window + 1 because we know window itself
3679 is resizable (otherwise we would have signalled an error. */
3681 struct window
*w
= XWINDOW (window
);
3685 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
3686 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
3688 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
3689 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
3694 /* Add delta1 lines or columns to this window, and to the parent,
3695 keeping things consistent while not affecting siblings. */
3696 XSETINT (CURSIZE (parent
), opht
+ delta1
);
3697 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
3699 /* Squeeze out delta1 lines or columns from our parent,
3700 shriking this window and siblings proportionately.
3701 This brings parent back to correct size.
3702 Delta1 was calculated so this makes this window the desired size,
3703 taking it all out of the siblings. */
3704 (*setsizefun
) (parent
, opht
, 0);
3709 XSETFASTINT (p
->last_modified
, 0);
3710 XSETFASTINT (p
->last_overlay_modified
, 0);
3712 /* Adjust glyph matrices. */
3713 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
3721 /***********************************************************************
3722 Resizing Mini-Windows
3723 ***********************************************************************/
3725 static void shrink_window_lowest_first
P_ ((struct window
*, int));
3727 enum save_restore_action
3734 static int save_restore_orig_size
P_ ((struct window
*,
3735 enum save_restore_action
));
3737 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
3738 from lowest windows first. */
3741 shrink_window_lowest_first (w
, height
)
3749 xassert (!MINI_WINDOW_P (w
));
3751 /* Set redisplay hints. */
3752 XSETFASTINT (w
->last_modified
, 0);
3753 XSETFASTINT (w
->last_overlay_modified
, 0);
3754 windows_or_buffers_changed
++;
3755 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
3757 old_height
= XFASTINT (w
->height
);
3758 XSETFASTINT (w
->height
, height
);
3760 if (!NILP (w
->hchild
))
3762 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
3764 c
= XWINDOW (child
);
3766 shrink_window_lowest_first (c
, height
);
3769 else if (!NILP (w
->vchild
))
3771 Lisp_Object last_child
;
3772 int delta
= old_height
- height
;
3777 /* Find the last child. We are taking space from lowest windows
3778 first, so we iterate over children from the last child
3780 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
3783 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
3784 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
3788 c
= XWINDOW (child
);
3789 this_one
= XFASTINT (c
->height
) - MIN_SAFE_WINDOW_HEIGHT
;
3791 if (this_one
> delta
)
3794 shrink_window_lowest_first (c
, XFASTINT (c
->height
) - this_one
);
3798 /* Compute new positions. */
3799 last_top
= XINT (w
->top
);
3800 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
3802 c
= XWINDOW (child
);
3803 c
->top
= make_number (last_top
);
3804 shrink_window_lowest_first (c
, XFASTINT (c
->height
));
3805 last_top
+= XFASTINT (c
->height
);
3811 /* Save, restore, or check positions and sizes in the window tree
3812 rooted at W. ACTION says what to do.
3814 If ACTION is CHECK_ORIG_SIZES, check if orig_top and orig_height
3815 members are valid for all windows in the window tree. Value is
3816 non-zero if they are valid.
3818 If ACTION is SAVE_ORIG_SIZES, save members top and height in
3819 orig_top and orig_height for all windows in the tree.
3821 If ACTION is RESTORE_ORIG_SIZES, restore top and height from
3822 values stored in orig_top and orig_height for all windows. */
3825 save_restore_orig_size (w
, action
)
3827 enum save_restore_action action
;
3833 if (!NILP (w
->hchild
))
3835 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
3838 else if (!NILP (w
->vchild
))
3840 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
3846 case CHECK_ORIG_SIZES
:
3847 if (!INTEGERP (w
->orig_top
) || !INTEGERP (w
->orig_height
))
3851 case SAVE_ORIG_SIZES
:
3852 w
->orig_top
= w
->top
;
3853 w
->orig_height
= w
->height
;
3854 XSETFASTINT (w
->last_modified
, 0);
3855 XSETFASTINT (w
->last_overlay_modified
, 0);
3858 case RESTORE_ORIG_SIZES
:
3859 xassert (INTEGERP (w
->orig_top
) && INTEGERP (w
->orig_height
));
3860 w
->top
= w
->orig_top
;
3861 w
->height
= w
->orig_height
;
3862 w
->orig_height
= w
->orig_top
= Qnil
;
3863 XSETFASTINT (w
->last_modified
, 0);
3864 XSETFASTINT (w
->last_overlay_modified
, 0);
3871 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
3878 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
3879 without deleting other windows. */
3882 grow_mini_window (w
, delta
)
3886 struct frame
*f
= XFRAME (w
->frame
);
3887 struct window
*root
;
3889 xassert (MINI_WINDOW_P (w
));
3890 xassert (delta
>= 0);
3892 /* Check values of window_min_width and window_min_height for
3894 check_min_window_sizes ();
3896 /* Compute how much we can enlarge the mini-window without deleting
3898 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3901 int min_height
= window_min_size (root
, 0, 0, 0);
3902 if (XFASTINT (root
->height
) - delta
< min_height
)
3903 /* Note that the root window may already be smaller than
3905 delta
= max (0, XFASTINT (root
->height
) - min_height
);
3910 /* Save original window sizes and positions, if not already done. */
3911 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
3912 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
3914 /* Shrink other windows. */
3915 shrink_window_lowest_first (root
, XFASTINT (root
->height
) - delta
);
3917 /* Grow the mini-window. */
3918 w
->top
= make_number (XFASTINT (root
->top
) + XFASTINT (root
->height
));
3919 w
->height
= make_number (XFASTINT (w
->height
) + delta
);
3920 XSETFASTINT (w
->last_modified
, 0);
3921 XSETFASTINT (w
->last_overlay_modified
, 0);
3928 /* Shrink mini-window W. If there is recorded info about window sizes
3929 before a call to grow_mini_window, restore recorded window sizes.
3930 Otherwise, if the mini-window is higher than 1 line, resize it to 1
3934 shrink_mini_window (w
)
3937 struct frame
*f
= XFRAME (w
->frame
);
3938 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3940 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
3942 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
3944 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3945 windows_or_buffers_changed
= 1;
3947 else if (XFASTINT (w
->height
) > 1)
3949 /* Distribute the additional lines of the mini-window
3950 among the other windows. */
3952 XSETWINDOW (window
, w
);
3953 enlarge_window (window
, 1 - XFASTINT (w
->height
), 0, 0);
3959 /* Mark window cursors off for all windows in the window tree rooted
3960 at W by setting their phys_cursor_on_p flag to zero. Called from
3961 xterm.c, e.g. when a frame is cleared and thereby all cursors on
3962 the frame are cleared. */
3965 mark_window_cursors_off (w
)
3970 if (!NILP (w
->hchild
))
3971 mark_window_cursors_off (XWINDOW (w
->hchild
));
3972 else if (!NILP (w
->vchild
))
3973 mark_window_cursors_off (XWINDOW (w
->vchild
));
3975 w
->phys_cursor_on_p
= 0;
3977 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3982 /* Return number of lines of text (not counting mode lines) in W. */
3985 window_internal_height (w
)
3988 int ht
= XFASTINT (w
->height
);
3990 if (!MINI_WINDOW_P (w
))
3992 if (!NILP (w
->parent
)
3993 || !NILP (w
->vchild
)
3994 || !NILP (w
->hchild
)
3997 || WINDOW_WANTS_MODELINE_P (w
))
4000 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4008 /* Return the number of columns in W.
4009 Don't count columns occupied by scroll bars or the vertical bar
4010 separating W from the sibling to its right. */
4013 window_internal_width (w
)
4016 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4017 int width
= XINT (w
->width
);
4019 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4020 /* Scroll bars occupy a few columns. */
4021 width
-= FRAME_SCROLL_BAR_COLS (f
);
4022 else if (!WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4023 /* The column of `|' characters separating side-by-side windows
4024 occupies one column only. */
4027 /* On window-systems, areas to the left and right of the window
4028 are used as fringes. */
4029 if (FRAME_WINDOW_P (f
))
4030 width
-= FRAME_FRINGE_COLS (f
);
4036 /************************************************************************
4038 ***********************************************************************/
4040 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4041 N screen-fulls, which is defined as the height of the window minus
4042 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4043 instead. Negative values of N mean scroll down. NOERROR non-zero
4044 means don't signal an error if we try to move over BEGV or ZV,
4048 window_scroll (window
, n
, whole
, noerror
)
4056 /* If we must, use the pixel-based version which is much slower than
4057 the line-based one but can handle varying line heights. */
4058 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4059 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4061 window_scroll_line_based (window
, n
, whole
, noerror
);
4067 /* Implementation of window_scroll that works based on pixel line
4068 heights. See the comment of window_scroll for parameter
4072 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4079 struct window
*w
= XWINDOW (window
);
4080 struct text_pos start
;
4082 int this_scroll_margin
;
4084 /* True if we fiddled the window vscroll field without really scrolling. */
4087 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4089 /* If PT is not visible in WINDOW, move back one half of
4090 the screen. Allow PT to be partially visible, otherwise
4091 something like (scroll-down 1) with PT in the line before
4092 the partially visible one would recenter. */
4093 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4096 /* Move backward half the height of the window. Performance note:
4097 vmotion used here is about 10% faster, but would give wrong
4098 results for variable height lines. */
4099 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4100 it
.current_y
= it
.last_visible_y
;
4101 move_it_vertically (&it
, - window_box_height (w
) / 2);
4103 /* The function move_iterator_vertically may move over more than
4104 the specified y-distance. If it->w is small, e.g. a
4105 mini-buffer window, we may end up in front of the window's
4106 display area. This is the case when Start displaying at the
4107 start of the line containing PT in this case. */
4108 if (it
.current_y
<= 0)
4110 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4111 move_it_vertically (&it
, 0);
4115 start
= it
.current
.pos
;
4118 /* If scroll_preserve_screen_position is non-zero, we try to set
4119 point in the same window line as it is now, so get that line. */
4120 if (!NILP (Vscroll_preserve_screen_position
))
4122 start_display (&it
, w
, start
);
4123 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4124 preserve_y
= it
.current_y
;
4129 /* Move iterator it from start the specified distance forward or
4130 backward. The result is the new window start. */
4131 start_display (&it
, w
, start
);
4134 int screen_full
= (window_box_height (w
)
4135 - next_screen_context_lines
* CANON_Y_UNIT (it
.f
));
4136 int dy
= n
* screen_full
;
4138 /* Note that move_it_vertically always moves the iterator to the
4139 start of a line. So, if the last line doesn't have a newline,
4140 we would end up at the start of the line ending at ZV. */
4142 move_it_vertically_backward (&it
, -dy
);
4144 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4145 MOVE_TO_POS
| MOVE_TO_Y
);
4148 move_it_by_lines (&it
, n
, 1);
4150 /* End if we end up at ZV or BEGV. */
4151 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4152 || (n
< 0 && IT_CHARPOS (it
) == BEGV
))
4154 if (IT_CHARPOS (it
) == ZV
)
4156 if (it
.current_y
< it
.last_visible_y
4157 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4158 >= it
.last_visible_y
))
4160 /* The last line was only partially visible, make it fully
4162 w
->vscroll
= (it
.last_visible_y
4163 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4164 adjust_glyphs (it
.f
);
4169 Fsignal (Qend_of_buffer
, Qnil
);
4173 if (w
->vscroll
!= 0)
4174 /* The first line was only partially visible, make it fully
4180 Fsignal (Qbeginning_of_buffer
, Qnil
);
4183 /* If control gets here, then we vscrolled. */
4185 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4187 /* Don't try to change the window start below. */
4193 int pos
= IT_CHARPOS (it
);
4195 /* Set the window start, and set up the window for redisplay. */
4196 set_marker_restricted (w
->start
, make_number (pos
),
4198 bytepos
= XMARKER (w
->start
)->bytepos
;
4199 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4201 w
->update_mode_line
= Qt
;
4202 XSETFASTINT (w
->last_modified
, 0);
4203 XSETFASTINT (w
->last_overlay_modified
, 0);
4204 /* Set force_start so that redisplay_window will run the
4205 window-scroll-functions. */
4206 w
->force_start
= Qt
;
4209 it
.current_y
= it
.vpos
= 0;
4211 /* Preserve the screen position if we must. */
4212 if (preserve_y
>= 0)
4214 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4215 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4219 /* Move PT out of scroll margins. */
4220 this_scroll_margin
= max (0, scroll_margin
);
4221 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->height
) / 4);
4222 this_scroll_margin
*= CANON_Y_UNIT (it
.f
);
4226 /* We moved the window start towards ZV, so PT may be now
4227 in the scroll margin at the top. */
4228 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4229 while (it
.current_y
< this_scroll_margin
)
4231 int prev
= it
.current_y
;
4232 move_it_by_lines (&it
, 1, 1);
4233 if (prev
== it
.current_y
)
4236 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4240 int charpos
, bytepos
;
4242 /* We moved the window start towards BEGV, so PT may be now
4243 in the scroll margin at the bottom. */
4244 move_it_to (&it
, PT
, -1,
4245 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4246 MOVE_TO_POS
| MOVE_TO_Y
);
4248 /* Save our position, in case it's correct. */
4249 charpos
= IT_CHARPOS (it
);
4250 bytepos
= IT_BYTEPOS (it
);
4252 /* See if point is on a partially visible line at the end. */
4253 move_it_by_lines (&it
, 1, 1);
4254 if (it
.current_y
> it
.last_visible_y
)
4255 /* The last line was only partially visible, so back up two
4256 lines to make sure we're on a fully visible line. */
4258 move_it_by_lines (&it
, -2, 0);
4259 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4262 /* No, the position we saved is OK, so use it. */
4263 SET_PT_BOTH (charpos
, bytepos
);
4269 /* Implementation of window_scroll that works based on screen lines.
4270 See the comment of window_scroll for parameter descriptions. */
4273 window_scroll_line_based (window
, n
, whole
, noerror
)
4279 register struct window
*w
= XWINDOW (window
);
4280 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4281 register int pos
, pos_byte
;
4282 register int ht
= window_internal_height (w
);
4283 register Lisp_Object tem
;
4287 struct position posit
;
4290 /* If scrolling screen-fulls, compute the number of lines to
4291 scroll from the window's height. */
4293 n
*= max (1, ht
- next_screen_context_lines
);
4295 startpos
= marker_position (w
->start
);
4297 posit
= *compute_motion (startpos
, 0, 0, 0,
4299 window_internal_width (w
), XINT (w
->hscroll
),
4301 original_vpos
= posit
.vpos
;
4303 XSETFASTINT (tem
, PT
);
4304 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4308 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4313 lose
= n
< 0 && PT
== BEGV
;
4314 Fvertical_motion (make_number (n
), window
);
4318 SET_PT_BOTH (opoint
, opoint_byte
);
4325 Fsignal (Qbeginning_of_buffer
, Qnil
);
4330 int this_scroll_margin
= scroll_margin
;
4332 /* Don't use a scroll margin that is negative or too large. */
4333 if (this_scroll_margin
< 0)
4334 this_scroll_margin
= 0;
4336 if (XINT (w
->height
) < 4 * scroll_margin
)
4337 this_scroll_margin
= XINT (w
->height
) / 4;
4339 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4340 w
->start_at_line_beg
= bolp
;
4341 w
->update_mode_line
= Qt
;
4342 XSETFASTINT (w
->last_modified
, 0);
4343 XSETFASTINT (w
->last_overlay_modified
, 0);
4344 /* Set force_start so that redisplay_window will run
4345 the window-scroll-functions. */
4346 w
->force_start
= Qt
;
4348 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4350 SET_PT_BOTH (pos
, pos_byte
);
4351 Fvertical_motion (make_number (original_vpos
), window
);
4353 /* If we scrolled forward, put point enough lines down
4354 that it is outside the scroll margin. */
4359 if (this_scroll_margin
> 0)
4361 SET_PT_BOTH (pos
, pos_byte
);
4362 Fvertical_motion (make_number (this_scroll_margin
), window
);
4368 if (top_margin
<= opoint
)
4369 SET_PT_BOTH (opoint
, opoint_byte
);
4370 else if (!NILP (Vscroll_preserve_screen_position
))
4372 SET_PT_BOTH (pos
, pos_byte
);
4373 Fvertical_motion (make_number (original_vpos
), window
);
4376 SET_PT (top_margin
);
4382 /* If we scrolled backward, put point near the end of the window
4383 but not within the scroll margin. */
4384 SET_PT_BOTH (pos
, pos_byte
);
4385 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4386 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4389 bottom_margin
= PT
+ 1;
4391 if (bottom_margin
> opoint
)
4392 SET_PT_BOTH (opoint
, opoint_byte
);
4395 if (!NILP (Vscroll_preserve_screen_position
))
4397 SET_PT_BOTH (pos
, pos_byte
);
4398 Fvertical_motion (make_number (original_vpos
), window
);
4401 Fvertical_motion (make_number (-1), window
);
4410 Fsignal (Qend_of_buffer
, Qnil
);
4415 /* Scroll selected_window up or down. If N is nil, scroll a
4416 screen-full which is defined as the height of the window minus
4417 next_screen_context_lines. If N is the symbol `-', scroll.
4418 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4419 up. This is the guts of Fscroll_up and Fscroll_down. */
4422 scroll_command (n
, direction
)
4426 int count
= SPECPDL_INDEX ();
4428 xassert (abs (direction
) == 1);
4430 /* If selected window's buffer isn't current, make it current for
4431 the moment. But don't screw up if window_scroll gets an error. */
4432 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4434 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4435 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4437 /* Make redisplay consider other windows than just selected_window. */
4438 ++windows_or_buffers_changed
;
4442 window_scroll (selected_window
, direction
, 1, 0);
4443 else if (EQ (n
, Qminus
))
4444 window_scroll (selected_window
, -direction
, 1, 0);
4447 n
= Fprefix_numeric_value (n
);
4448 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4451 unbind_to (count
, Qnil
);
4454 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
4455 doc
: /* Scroll text of current window upward ARG lines; or near full screen if no ARG.
4456 A near full screen is `next-screen-context-lines' less than a full screen.
4457 Negative ARG means scroll downward.
4458 If ARG is the atom `-', scroll downward by nearly full screen.
4459 When calling from a program, supply as argument a number, nil, or `-'. */)
4463 scroll_command (arg
, 1);
4467 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
4468 doc
: /* Scroll text of current window down ARG lines; or near full screen if no ARG.
4469 A near full screen is `next-screen-context-lines' less than a full screen.
4470 Negative ARG means scroll upward.
4471 If ARG is the atom `-', scroll upward by nearly full screen.
4472 When calling from a program, supply as argument a number, nil, or `-'. */)
4476 scroll_command (arg
, -1);
4480 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4481 doc
: /* Return the other window for \"other window scroll\" commands.
4482 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4483 specifies the window.
4484 If `other-window-scroll-buffer' is non-nil, a window
4485 showing that buffer is used. */)
4490 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4491 && !NILP (Vminibuf_scroll_window
))
4492 window
= Vminibuf_scroll_window
;
4493 /* If buffer is specified, scroll that buffer. */
4494 else if (!NILP (Vother_window_scroll_buffer
))
4496 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4498 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4502 /* Nothing specified; look for a neighboring window on the same
4504 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4506 if (EQ (window
, selected_window
))
4507 /* That didn't get us anywhere; look for a window on another
4510 window
= Fnext_window (window
, Qnil
, Qt
);
4511 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4512 && ! EQ (window
, selected_window
));
4515 CHECK_LIVE_WINDOW (window
);
4517 if (EQ (window
, selected_window
))
4518 error ("There is no other window");
4523 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4524 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4525 A near full screen is `next-screen-context-lines' less than a full screen.
4526 The next window is the one below the current one; or the one at the top
4527 if the current one is at the bottom. Negative ARG means scroll downward.
4528 If ARG is the atom `-', scroll downward by nearly full screen.
4529 When calling from a program, supply as argument a number, nil, or `-'.
4531 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4532 specifies the window to scroll.
4533 If `other-window-scroll-buffer' is non-nil, scroll the window
4534 showing that buffer, popping the buffer up if necessary. */)
4540 int count
= SPECPDL_INDEX ();
4542 window
= Fother_window_for_scrolling ();
4543 w
= XWINDOW (window
);
4545 /* Don't screw up if window_scroll gets an error. */
4546 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4547 ++windows_or_buffers_changed
;
4549 Fset_buffer (w
->buffer
);
4550 SET_PT (marker_position (w
->pointm
));
4553 window_scroll (window
, 1, 1, 1);
4554 else if (EQ (arg
, Qminus
))
4555 window_scroll (window
, -1, 1, 1);
4561 window_scroll (window
, XINT (arg
), 0, 1);
4564 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4565 unbind_to (count
, Qnil
);
4570 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
4571 doc
: /* Scroll selected window display ARG columns left.
4572 Default for ARG is window width minus 2.
4573 Value is the total amount of leftward horizontal scrolling in
4574 effect after the change.
4575 If `automatic-hscrolling' is non-nil, the argument ARG modifies
4576 a lower bound for automatic scrolling, i.e. automatic scrolling
4577 will not scroll a window to a column less than the value returned
4578 by this function. */)
4580 register Lisp_Object arg
;
4584 struct window
*w
= XWINDOW (selected_window
);
4587 XSETFASTINT (arg
, window_internal_width (w
) - 2);
4589 arg
= Fprefix_numeric_value (arg
);
4591 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
4592 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4594 if (interactive_p (0))
4595 w
->min_hscroll
= w
->hscroll
;
4600 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
4601 doc
: /* Scroll selected window display ARG columns right.
4602 Default for ARG is window width minus 2.
4603 Value is the total amount of leftward horizontal scrolling in
4604 effect after the change.
4605 If `automatic-hscrolling' is non-nil, the argument ARG modifies
4606 a lower bound for automatic scrolling, i.e. automatic scrolling
4607 will not scroll a window to a column less than the value returned
4608 by this function. */)
4610 register Lisp_Object arg
;
4614 struct window
*w
= XWINDOW (selected_window
);
4617 XSETFASTINT (arg
, window_internal_width (w
) - 2);
4619 arg
= Fprefix_numeric_value (arg
);
4621 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
4622 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4624 if (interactive_p (0))
4625 w
->min_hscroll
= w
->hscroll
;
4630 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
4631 doc
: /* Return the window which was selected when entering the minibuffer.
4632 Returns nil, if current window is not a minibuffer window. */)
4635 if (minibuf_level
> 0
4636 && MINI_WINDOW_P (XWINDOW (selected_window
))
4637 && !NILP (minibuf_selected_window
)
4638 && WINDOW_LIVE_P (minibuf_selected_window
))
4639 return minibuf_selected_window
;
4644 /* Value is the number of lines actually displayed in window W,
4645 as opposed to its height. */
4648 displayed_window_lines (w
)
4652 struct text_pos start
;
4653 int height
= window_box_height (w
);
4654 struct buffer
*old_buffer
;
4657 if (XBUFFER (w
->buffer
) != current_buffer
)
4659 old_buffer
= current_buffer
;
4660 set_buffer_internal (XBUFFER (w
->buffer
));
4665 /* In case W->start is out of the accessible range, do something
4666 reasonable. This happens in Info mode when Info-scroll-down
4667 calls (recenter -1) while W->start is 1. */
4668 if (XMARKER (w
->start
)->charpos
< BEGV
)
4669 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4670 else if (XMARKER (w
->start
)->charpos
> ZV
)
4671 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
4673 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4675 start_display (&it
, w
, start
);
4676 move_it_vertically (&it
, height
);
4677 bottom_y
= line_bottom_y (&it
);
4679 /* rms: On a non-window display,
4680 the value of it.vpos at the bottom of the screen
4681 seems to be 1 larger than window_box_height (w).
4682 This kludge fixes a bug whereby (move-to-window-line -1)
4683 when ZV is on the last screen line
4684 moves to the previous screen line instead of the last one. */
4685 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
4688 /* Add in empty lines at the bottom of the window. */
4689 if (bottom_y
< height
)
4691 int uy
= CANON_Y_UNIT (it
.f
);
4692 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
4696 set_buffer_internal (old_buffer
);
4702 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
4703 doc
: /* Center point in window and redisplay frame.
4704 With prefix argument ARG, recenter putting point on screen line ARG
4705 relative to the current window. If ARG is negative, it counts up from the
4706 bottom of the window. (ARG should be less than the height of the window.)
4708 If ARG is omitted or nil, erase the entire frame and then
4709 redraw with point in the center of the current window.
4710 Just C-u as prefix means put point in the center of the window
4711 and redisplay normally--don't erase and redraw the frame. */)
4713 register Lisp_Object arg
;
4715 struct window
*w
= XWINDOW (selected_window
);
4716 struct buffer
*buf
= XBUFFER (w
->buffer
);
4717 struct buffer
*obuf
= current_buffer
;
4719 int charpos
, bytepos
;
4721 /* If redisplay is suppressed due to an error, try again. */
4722 obuf
->display_error_modiff
= 0;
4728 /* Invalidate pixel data calculated for all compositions. */
4729 for (i
= 0; i
< n_compositions
; i
++)
4730 composition_table
[i
]->font
= NULL
;
4732 Fredraw_frame (w
->frame
);
4733 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
4736 else if (CONSP (arg
)) /* Just C-u. */
4740 arg
= Fprefix_numeric_value (arg
);
4744 set_buffer_internal (buf
);
4746 /* Handle centering on a graphical frame specially. Such frames can
4747 have variable-height lines and centering point on the basis of
4748 line counts would lead to strange effects. */
4749 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
4756 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
4757 start_display (&it
, w
, pt
);
4758 move_it_vertically (&it
, - window_box_height (w
) / 2);
4759 charpos
= IT_CHARPOS (it
);
4760 bytepos
= IT_BYTEPOS (it
);
4762 else if (XINT (arg
) < 0)
4766 int y0
, y1
, h
, nlines
;
4768 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
4769 start_display (&it
, w
, pt
);
4772 /* The amount of pixels we have to move back is the window
4773 height minus what's displayed in the line containing PT,
4774 and the lines below. */
4775 nlines
= - XINT (arg
) - 1;
4776 move_it_by_lines (&it
, nlines
, 1);
4778 y1
= line_bottom_y (&it
);
4780 /* If we can't move down NLINES lines because we hit
4781 the end of the buffer, count in some empty lines. */
4782 if (it
.vpos
< nlines
)
4783 y1
+= (nlines
- it
.vpos
) * CANON_Y_UNIT (it
.f
);
4785 h
= window_box_height (w
) - (y1
- y0
);
4787 start_display (&it
, w
, pt
);
4788 move_it_vertically (&it
, - h
);
4789 charpos
= IT_CHARPOS (it
);
4790 bytepos
= IT_BYTEPOS (it
);
4794 struct position pos
;
4795 pos
= *vmotion (PT
, - XINT (arg
), w
);
4796 charpos
= pos
.bufpos
;
4797 bytepos
= pos
.bytepos
;
4802 struct position pos
;
4803 int ht
= window_internal_height (w
);
4806 arg
= make_number (ht
/ 2);
4807 else if (XINT (arg
) < 0)
4808 arg
= make_number (XINT (arg
) + ht
);
4810 pos
= *vmotion (PT
, - XINT (arg
), w
);
4811 charpos
= pos
.bufpos
;
4812 bytepos
= pos
.bytepos
;
4815 /* Set the new window start. */
4816 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
4817 w
->window_end_valid
= Qnil
;
4819 w
->optional_new_start
= Qt
;
4821 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
4822 w
->start_at_line_beg
= Qt
;
4824 w
->start_at_line_beg
= Qnil
;
4826 set_buffer_internal (obuf
);
4831 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
4833 doc
: /* Return the height in lines of the text display area of WINDOW.
4834 This doesn't include the mode-line (or header-line if any) or any
4835 partial-height lines in the text display area. */)
4839 struct window
*w
= decode_window (window
);
4840 int pixel_height
= window_box_height (w
);
4841 int line_height
= pixel_height
/ CANON_Y_UNIT (XFRAME (w
->frame
));
4842 return make_number (line_height
);
4847 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
4849 doc
: /* Position point relative to window.
4850 With no argument, position point at center of window.
4851 An argument specifies vertical position within the window;
4852 zero means top of window, negative means relative to bottom of window. */)
4856 struct window
*w
= XWINDOW (selected_window
);
4860 window
= selected_window
;
4861 start
= marker_position (w
->start
);
4862 if (start
< BEGV
|| start
> ZV
)
4864 int height
= window_internal_height (w
);
4865 Fvertical_motion (make_number (- (height
/ 2)), window
);
4866 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
4867 w
->start_at_line_beg
= Fbolp ();
4868 w
->force_start
= Qt
;
4871 Fgoto_char (w
->start
);
4873 lines
= displayed_window_lines (w
);
4875 XSETFASTINT (arg
, lines
/ 2);
4878 arg
= Fprefix_numeric_value (arg
);
4880 XSETINT (arg
, XINT (arg
) + lines
);
4883 /* Skip past a partially visible first line. */
4885 XSETINT (arg
, XINT (arg
) + 1);
4887 return Fvertical_motion (arg
, window
);
4892 /***********************************************************************
4893 Window Configuration
4894 ***********************************************************************/
4896 struct save_window_data
4898 EMACS_INT size_from_Lisp_Vector_struct
;
4899 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
4900 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
4901 Lisp_Object frame_tool_bar_lines
;
4902 Lisp_Object selected_frame
;
4903 Lisp_Object current_window
;
4904 Lisp_Object current_buffer
;
4905 Lisp_Object minibuf_scroll_window
;
4906 Lisp_Object minibuf_selected_window
;
4907 Lisp_Object root_window
;
4908 Lisp_Object focus_frame
;
4909 /* Record the values of window-min-width and window-min-height
4910 so that window sizes remain consistent with them. */
4911 Lisp_Object min_width
, min_height
;
4912 /* A vector, each of whose elements is a struct saved_window
4914 Lisp_Object saved_windows
;
4917 /* This is saved as a Lisp_Vector */
4920 /* these first two must agree with struct Lisp_Vector in lisp.h */
4921 EMACS_INT size_from_Lisp_Vector_struct
;
4922 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
4925 Lisp_Object buffer
, start
, pointm
, mark
;
4926 Lisp_Object left
, top
, width
, height
, hscroll
, min_hscroll
;
4927 Lisp_Object parent
, prev
;
4928 Lisp_Object start_at_line_beg
;
4929 Lisp_Object display_table
;
4930 Lisp_Object orig_top
, orig_height
;
4933 #define SAVED_WINDOW_VECTOR_SIZE 17 /* Arg to Fmake_vector */
4935 #define SAVED_WINDOW_N(swv,n) \
4936 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
4938 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
4939 doc
: /* Return t if OBJECT is a window-configuration object. */)
4943 if (WINDOW_CONFIGURATIONP (object
))
4948 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
4949 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
4953 register struct save_window_data
*data
;
4954 struct Lisp_Vector
*saved_windows
;
4956 if (! WINDOW_CONFIGURATIONP (config
))
4957 wrong_type_argument (Qwindow_configuration_p
, config
);
4959 data
= (struct save_window_data
*) XVECTOR (config
);
4960 saved_windows
= XVECTOR (data
->saved_windows
);
4961 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
4964 DEFUN ("set-window-configuration", Fset_window_configuration
,
4965 Sset_window_configuration
, 1, 1, 0,
4966 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
4967 CONFIGURATION must be a value previously returned
4968 by `current-window-configuration' (which see).
4969 If CONFIGURATION was made from a frame that is now deleted,
4970 only frame-independent values can be restored. In this case,
4971 the return value is nil. Otherwise the value is t. */)
4973 Lisp_Object configuration
;
4975 register struct save_window_data
*data
;
4976 struct Lisp_Vector
*saved_windows
;
4977 Lisp_Object new_current_buffer
;
4982 while (!WINDOW_CONFIGURATIONP (configuration
))
4983 wrong_type_argument (Qwindow_configuration_p
, configuration
);
4985 data
= (struct save_window_data
*) XVECTOR (configuration
);
4986 saved_windows
= XVECTOR (data
->saved_windows
);
4988 new_current_buffer
= data
->current_buffer
;
4989 if (NILP (XBUFFER (new_current_buffer
)->name
))
4990 new_current_buffer
= Qnil
;
4993 if (XBUFFER (new_current_buffer
) == current_buffer
)
4996 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
4999 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5002 /* If f is a dead frame, don't bother rebuilding its window tree.
5003 However, there is other stuff we should still try to do below. */
5004 if (FRAME_LIVE_P (f
))
5006 register struct window
*w
;
5007 register struct saved_window
*p
;
5008 struct window
*root_window
;
5009 struct window
**leaf_windows
;
5013 /* If the frame has been resized since this window configuration was
5014 made, we change the frame to the size specified in the
5015 configuration, restore the configuration, and then resize it
5016 back. We keep track of the prevailing height in these variables. */
5017 int previous_frame_height
= FRAME_HEIGHT (f
);
5018 int previous_frame_width
= FRAME_WIDTH (f
);
5019 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5020 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5022 /* The mouse highlighting code could get screwed up
5023 if it runs during this. */
5026 if (XFASTINT (data
->frame_height
) != previous_frame_height
5027 || XFASTINT (data
->frame_width
) != previous_frame_width
)
5028 change_frame_size (f
, XFASTINT (data
->frame_height
),
5029 XFASTINT (data
->frame_width
), 0, 0, 0);
5030 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5031 if (XFASTINT (data
->frame_menu_bar_lines
)
5032 != previous_frame_menu_bar_lines
)
5033 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5034 #ifdef HAVE_WINDOW_SYSTEM
5035 if (XFASTINT (data
->frame_tool_bar_lines
)
5036 != previous_frame_tool_bar_lines
)
5037 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5041 /* "Swap out" point from the selected window
5042 into its buffer. We do this now, before
5043 restoring the window contents, and prevent it from
5044 being done later on when we select a new window. */
5045 if (! NILP (XWINDOW (selected_window
)->buffer
))
5047 w
= XWINDOW (selected_window
);
5048 set_marker_both (w
->pointm
,
5050 BUF_PT (XBUFFER (w
->buffer
)),
5051 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5054 windows_or_buffers_changed
++;
5055 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5057 /* Problem: Freeing all matrices and later allocating them again
5058 is a serious redisplay flickering problem. What we would
5059 really like to do is to free only those matrices not reused
5061 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5063 = (struct window
**) alloca (count_windows (root_window
)
5064 * sizeof (struct window
*));
5065 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5067 /* Temporarily avoid any problems with windows that are smaller
5068 than they are supposed to be. */
5069 window_min_height
= 1;
5070 window_min_width
= 1;
5073 Mark all windows now on frame as "deleted".
5074 Restoring the new configuration "undeletes" any that are in it.
5076 Save their current buffers in their height fields, since we may
5077 need it later, if a buffer saved in the configuration is now
5079 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5081 for (k
= 0; k
< saved_windows
->size
; k
++)
5083 p
= SAVED_WINDOW_N (saved_windows
, k
);
5084 w
= XWINDOW (p
->window
);
5087 if (!NILP (p
->parent
))
5088 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5089 XFASTINT (p
->parent
))->window
;
5093 if (!NILP (p
->prev
))
5095 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5096 XFASTINT (p
->prev
))->window
;
5097 XWINDOW (w
->prev
)->next
= p
->window
;
5102 if (!NILP (w
->parent
))
5104 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
5106 XWINDOW (w
->parent
)->vchild
= p
->window
;
5107 XWINDOW (w
->parent
)->hchild
= Qnil
;
5111 XWINDOW (w
->parent
)->hchild
= p
->window
;
5112 XWINDOW (w
->parent
)->vchild
= Qnil
;
5117 /* If we squirreled away the buffer in the window's height,
5119 if (BUFFERP (w
->height
))
5120 w
->buffer
= w
->height
;
5123 w
->width
= p
->width
;
5124 w
->height
= p
->height
;
5125 w
->hscroll
= p
->hscroll
;
5126 w
->min_hscroll
= p
->min_hscroll
;
5127 w
->display_table
= p
->display_table
;
5128 w
->orig_top
= p
->orig_top
;
5129 w
->orig_height
= p
->orig_height
;
5130 XSETFASTINT (w
->last_modified
, 0);
5131 XSETFASTINT (w
->last_overlay_modified
, 0);
5133 /* Reinstall the saved buffer and pointers into it. */
5134 if (NILP (p
->buffer
))
5135 w
->buffer
= p
->buffer
;
5138 if (!NILP (XBUFFER (p
->buffer
)->name
))
5139 /* If saved buffer is alive, install it. */
5141 w
->buffer
= p
->buffer
;
5142 w
->start_at_line_beg
= p
->start_at_line_beg
;
5143 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5144 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5145 Fset_marker (XBUFFER (w
->buffer
)->mark
,
5146 p
->mark
, w
->buffer
);
5148 /* As documented in Fcurrent_window_configuration, don't
5149 restore the location of point in the buffer which was
5150 current when the window configuration was recorded. */
5151 if (!EQ (p
->buffer
, new_current_buffer
)
5152 && XBUFFER (p
->buffer
) == current_buffer
)
5153 Fgoto_char (w
->pointm
);
5155 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
5156 /* Else unless window has a live buffer, get one. */
5158 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5159 /* This will set the markers to beginning of visible
5161 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5162 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5163 w
->start_at_line_beg
= Qt
;
5166 /* Keeping window's old buffer; make sure the markers
5169 /* Set window markers at start of visible range. */
5170 if (XMARKER (w
->start
)->buffer
== 0)
5171 set_marker_restricted (w
->start
, make_number (0),
5173 if (XMARKER (w
->pointm
)->buffer
== 0)
5174 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5175 BUF_PT (XBUFFER (w
->buffer
)),
5176 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5177 w
->start_at_line_beg
= Qt
;
5182 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5183 /* Prevent "swapping out point" in the old selected window
5184 using the buffer that has been restored into it.
5185 Use the point value from the beginning of this function
5186 since unshow_buffer (called from delete_all_subwindows)
5187 could have altered it. */
5188 selected_window
= Qnil
;
5189 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5190 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5191 make_number (old_point
),
5192 XWINDOW (data
->current_window
)->buffer
);
5194 Fselect_window (data
->current_window
);
5195 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
5198 if (NILP (data
->focus_frame
)
5199 || (FRAMEP (data
->focus_frame
)
5200 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5201 Fredirect_frame_focus (frame
, data
->focus_frame
);
5203 #if 0 /* I don't understand why this is needed, and it causes problems
5204 when the frame's old selected window has been deleted. */
5205 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
5206 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5210 /* Set the screen height to the value it had before this function. */
5211 if (previous_frame_height
!= FRAME_HEIGHT (f
)
5212 || previous_frame_width
!= FRAME_WIDTH (f
))
5213 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
5215 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5216 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5217 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5219 #ifdef HAVE_WINDOW_SYSTEM
5220 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5221 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5226 /* Now, free glyph matrices in windows that were not reused. */
5227 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5229 if (NILP (leaf_windows
[i
]->buffer
))
5231 /* Assert it's not reused as a combination. */
5232 xassert (NILP (leaf_windows
[i
]->hchild
)
5233 && NILP (leaf_windows
[i
]->vchild
));
5234 free_window_matrices (leaf_windows
[i
]);
5236 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5244 /* Fselect_window will have made f the selected frame, so we
5245 reselect the proper frame here. Fhandle_switch_frame will change the
5246 selected window too, but that doesn't make the call to
5247 Fselect_window above totally superfluous; it still sets f's
5249 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5250 do_switch_frame (data
->selected_frame
, 0, 0);
5252 if (! NILP (Vwindow_configuration_change_hook
)
5253 && ! NILP (Vrun_hooks
))
5254 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5257 if (!NILP (new_current_buffer
))
5258 Fset_buffer (new_current_buffer
);
5260 /* Restore the minimum heights recorded in the configuration. */
5261 window_min_height
= XINT (data
->min_height
);
5262 window_min_width
= XINT (data
->min_width
);
5264 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5265 minibuf_selected_window
= data
->minibuf_selected_window
;
5267 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5270 /* Mark all windows now on frame as deleted
5271 by setting their buffers to nil. */
5274 delete_all_subwindows (w
)
5275 register struct window
*w
;
5277 if (!NILP (w
->next
))
5278 delete_all_subwindows (XWINDOW (w
->next
));
5279 if (!NILP (w
->vchild
))
5280 delete_all_subwindows (XWINDOW (w
->vchild
));
5281 if (!NILP (w
->hchild
))
5282 delete_all_subwindows (XWINDOW (w
->hchild
));
5284 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5286 if (!NILP (w
->buffer
))
5289 /* We set all three of these fields to nil, to make sure that we can
5290 distinguish this dead window from any live window. Live leaf
5291 windows will have buffer set, and combination windows will have
5292 vchild or hchild set. */
5297 Vwindow_list
= Qnil
;
5301 count_windows (window
)
5302 register struct window
*window
;
5304 register int count
= 1;
5305 if (!NILP (window
->next
))
5306 count
+= count_windows (XWINDOW (window
->next
));
5307 if (!NILP (window
->vchild
))
5308 count
+= count_windows (XWINDOW (window
->vchild
));
5309 if (!NILP (window
->hchild
))
5310 count
+= count_windows (XWINDOW (window
->hchild
));
5315 /* Fill vector FLAT with leaf windows under W, starting at index I.
5316 Value is last index + 1. */
5319 get_leaf_windows (w
, flat
, i
)
5321 struct window
**flat
;
5326 if (!NILP (w
->hchild
))
5327 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5328 else if (!NILP (w
->vchild
))
5329 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5333 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5340 /* Return a pointer to the glyph W's physical cursor is on. Value is
5341 null if W's current matrix is invalid, so that no meaningfull glyph
5345 get_phys_cursor_glyph (w
)
5348 struct glyph_row
*row
;
5349 struct glyph
*glyph
;
5351 if (w
->phys_cursor
.vpos
>= 0
5352 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5353 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5355 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5356 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5365 save_window_save (window
, vector
, i
)
5367 struct Lisp_Vector
*vector
;
5370 register struct saved_window
*p
;
5371 register struct window
*w
;
5372 register Lisp_Object tem
;
5374 for (;!NILP (window
); window
= w
->next
)
5376 p
= SAVED_WINDOW_N (vector
, i
);
5377 w
= XWINDOW (window
);
5379 XSETFASTINT (w
->temslot
, i
++);
5381 p
->buffer
= w
->buffer
;
5384 p
->width
= w
->width
;
5385 p
->height
= w
->height
;
5386 p
->hscroll
= w
->hscroll
;
5387 p
->min_hscroll
= w
->min_hscroll
;
5388 p
->display_table
= w
->display_table
;
5389 p
->orig_top
= w
->orig_top
;
5390 p
->orig_height
= w
->orig_height
;
5391 if (!NILP (w
->buffer
))
5393 /* Save w's value of point in the window configuration.
5394 If w is the selected window, then get the value of point
5395 from the buffer; pointm is garbage in the selected window. */
5396 if (EQ (window
, selected_window
))
5398 p
->pointm
= Fmake_marker ();
5399 set_marker_both (p
->pointm
, w
->buffer
,
5400 BUF_PT (XBUFFER (w
->buffer
)),
5401 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5404 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5406 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5407 p
->start_at_line_beg
= w
->start_at_line_beg
;
5409 tem
= XBUFFER (w
->buffer
)->mark
;
5410 p
->mark
= Fcopy_marker (tem
, Qnil
);
5417 p
->start_at_line_beg
= Qnil
;
5420 if (NILP (w
->parent
))
5423 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5428 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5430 if (!NILP (w
->vchild
))
5431 i
= save_window_save (w
->vchild
, vector
, i
);
5432 if (!NILP (w
->hchild
))
5433 i
= save_window_save (w
->hchild
, vector
, i
);
5439 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5440 Scurrent_window_configuration
, 0, 1, 0,
5441 doc
: /* Return an object representing the current window configuration of FRAME.
5442 If FRAME is nil or omitted, use the selected frame.
5443 This describes the number of windows, their sizes and current buffers,
5444 and for each displayed buffer, where display starts, and the positions of
5445 point and mark. An exception is made for point in the current buffer:
5446 its value is -not- saved.
5447 This also records the currently selected frame, and FRAME's focus
5448 redirection (see `redirect-frame-focus'). */)
5452 register Lisp_Object tem
;
5453 register int n_windows
;
5454 register struct save_window_data
*data
;
5455 register struct Lisp_Vector
*vec
;
5460 frame
= selected_frame
;
5461 CHECK_LIVE_FRAME (frame
);
5464 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5465 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
5466 data
= (struct save_window_data
*)vec
;
5468 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
5469 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
5470 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
5471 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
5472 data
->selected_frame
= selected_frame
;
5473 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5474 XSETBUFFER (data
->current_buffer
, current_buffer
);
5475 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
5476 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
5477 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5478 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5479 XSETINT (data
->min_height
, window_min_height
);
5480 XSETINT (data
->min_width
, window_min_width
);
5481 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5482 data
->saved_windows
= tem
;
5483 for (i
= 0; i
< n_windows
; i
++)
5484 XVECTOR (tem
)->contents
[i
]
5485 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
5486 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5487 XSETWINDOW_CONFIGURATION (tem
, data
);
5491 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
5493 doc
: /* Execute body, preserving window sizes and contents.
5494 Restore which buffer appears in which window, where display starts,
5495 and the value of point and mark for each window.
5496 Also restore the choice of selected window.
5497 Also restore which buffer is current.
5498 Does not restore the value of point in current buffer.
5499 usage: (save-window-excursion BODY ...) */)
5503 register Lisp_Object val
;
5504 register int count
= SPECPDL_INDEX ();
5506 record_unwind_protect (Fset_window_configuration
,
5507 Fcurrent_window_configuration (Qnil
));
5508 val
= Fprogn (args
);
5509 return unbind_to (count
, val
);
5513 /***********************************************************************
5515 ***********************************************************************/
5517 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5519 doc
: /* Set width of marginal areas of window WINDOW.
5520 If window is nil, set margins of the currently selected window.
5521 First parameter LEFT-WIDTH specifies the number of character
5522 cells to reserve for the left marginal area. Second parameter
5523 RIGHT-WIDTH does the same for the right marginal area.
5524 A nil width parameter means no margin. */)
5525 (window
, left
, right
)
5526 Lisp_Object window
, left
, right
;
5528 struct window
*w
= decode_window (window
);
5531 CHECK_NUMBER_OR_FLOAT (left
);
5533 CHECK_NUMBER_OR_FLOAT (right
);
5535 /* Check widths < 0 and translate a zero width to nil.
5536 Margins that are too wide have to be checked elsewhere. */
5537 if ((INTEGERP (left
) && XINT (left
) < 0)
5538 || (FLOATP (left
) && XFLOAT_DATA (left
) <= 0))
5539 XSETFASTINT (left
, 0);
5540 if (INTEGERP (left
) && XFASTINT (left
) == 0)
5543 if ((INTEGERP (right
) && XINT (right
) < 0)
5544 || (FLOATP (right
) && XFLOAT_DATA (right
) <= 0))
5545 XSETFASTINT (right
, 0);
5546 if (INTEGERP (right
) && XFASTINT (right
) == 0)
5549 w
->left_margin_width
= left
;
5550 w
->right_margin_width
= right
;
5552 ++windows_or_buffers_changed
;
5553 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
5558 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
5560 doc
: /* Get width of marginal areas of window WINDOW.
5561 If WINDOW is omitted or nil, use the currently selected window.
5562 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
5563 If a marginal area does not exist, its width will be returned
5568 struct window
*w
= decode_window (window
);
5569 return Fcons (w
->left_margin_width
, w
->right_margin_width
);
5574 /***********************************************************************
5576 ***********************************************************************/
5578 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 1, 0,
5579 doc
: /* Return the amount by which WINDOW is scrolled vertically.
5580 Use the selected window if WINDOW is nil or omitted.
5581 Value is a multiple of the canonical character height of WINDOW. */)
5590 window
= selected_window
;
5592 CHECK_WINDOW (window
);
5593 w
= XWINDOW (window
);
5594 f
= XFRAME (w
->frame
);
5596 if (FRAME_WINDOW_P (f
))
5597 result
= CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
);
5599 result
= make_number (0);
5604 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
5606 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
5607 WINDOW nil means use the selected window. VSCROLL is a non-negative
5608 multiple of the canonical character height of WINDOW. */)
5610 Lisp_Object window
, vscroll
;
5616 window
= selected_window
;
5618 CHECK_WINDOW (window
);
5619 CHECK_NUMBER_OR_FLOAT (vscroll
);
5621 w
= XWINDOW (window
);
5622 f
= XFRAME (w
->frame
);
5624 if (FRAME_WINDOW_P (f
))
5626 int old_dy
= w
->vscroll
;
5628 w
->vscroll
= - CANON_Y_UNIT (f
) * XFLOATINT (vscroll
);
5629 w
->vscroll
= min (w
->vscroll
, 0);
5631 /* Adjust glyph matrix of the frame if the virtual display
5632 area becomes larger than before. */
5633 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
5636 /* Prevent redisplay shortcuts. */
5637 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5640 return Fwindow_vscroll (window
);
5644 /* Call FN for all leaf windows on frame F. FN is called with the
5645 first argument being a pointer to the leaf window, and with
5646 additional argument USER_DATA. Stops when FN returns 0. */
5649 foreach_window (f
, fn
, user_data
)
5651 int (* fn
) P_ ((struct window
*, void *));
5654 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
5658 /* Helper function for foreach_window. Call FN for all leaf windows
5659 reachable from W. FN is called with the first argument being a
5660 pointer to the leaf window, and with additional argument USER_DATA.
5661 Stop when FN returns 0. Value is 0 if stopped by FN. */
5664 foreach_window_1 (w
, fn
, user_data
)
5666 int (* fn
) P_ ((struct window
*, void *));
5671 for (cont
= 1; w
&& cont
;)
5673 if (!NILP (w
->hchild
))
5674 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
5675 else if (!NILP (w
->vchild
))
5676 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
5678 cont
= fn (w
, user_data
);
5680 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5687 /* Freeze or unfreeze the window start of W unless it is a
5688 mini-window or the selected window. FREEZE_P non-null means freeze
5689 the window start. */
5692 freeze_window_start (w
, freeze_p
)
5696 if (w
== XWINDOW (selected_window
)
5697 || MINI_WINDOW_P (w
)
5698 || (MINI_WINDOW_P (XWINDOW (selected_window
))
5699 && ! NILP (Vminibuf_scroll_window
)
5700 && w
== XWINDOW (Vminibuf_scroll_window
)))
5703 w
->frozen_window_start_p
= freeze_p
!= NULL
;
5708 /* Freeze or unfreeze the window starts of all leaf windows on frame
5709 F, except the selected window and a mini-window. FREEZE_P non-zero
5710 means freeze the window start. */
5713 freeze_window_starts (f
, freeze_p
)
5717 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
5721 /***********************************************************************
5723 ***********************************************************************/
5725 /* Return 1 if window configurations C1 and C2
5726 describe the same state of affairs. This is used by Fequal. */
5729 compare_window_configurations (c1
, c2
, ignore_positions
)
5731 int ignore_positions
;
5733 register struct save_window_data
*d1
, *d2
;
5734 struct Lisp_Vector
*sw1
, *sw2
;
5737 if (!WINDOW_CONFIGURATIONP (c1
))
5738 wrong_type_argument (Qwindow_configuration_p
, c1
);
5739 if (!WINDOW_CONFIGURATIONP (c2
))
5740 wrong_type_argument (Qwindow_configuration_p
, c2
);
5742 d1
= (struct save_window_data
*) XVECTOR (c1
);
5743 d2
= (struct save_window_data
*) XVECTOR (c2
);
5744 sw1
= XVECTOR (d1
->saved_windows
);
5745 sw2
= XVECTOR (d2
->saved_windows
);
5747 if (! EQ (d1
->frame_width
, d2
->frame_width
))
5749 if (! EQ (d1
->frame_height
, d2
->frame_height
))
5751 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
5753 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
5755 /* Don't compare the current_window field directly.
5756 Instead see w1_is_current and w2_is_current, below. */
5757 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
5759 if (! ignore_positions
)
5761 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
5763 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
5766 /* Don't compare the root_window field.
5767 We don't require the two configurations
5768 to use the same window object,
5769 and the two root windows must be equivalent
5770 if everything else compares equal. */
5771 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
5773 if (! EQ (d1
->min_width
, d2
->min_width
))
5775 if (! EQ (d1
->min_height
, d2
->min_height
))
5778 /* Verify that the two confis have the same number of windows. */
5779 if (sw1
->size
!= sw2
->size
)
5782 for (i
= 0; i
< sw1
->size
; i
++)
5784 struct saved_window
*p1
, *p2
;
5785 int w1_is_current
, w2_is_current
;
5787 p1
= SAVED_WINDOW_N (sw1
, i
);
5788 p2
= SAVED_WINDOW_N (sw2
, i
);
5790 /* Verify that the current windows in the two
5791 configurations correspond to each other. */
5792 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
5793 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
5795 if (w1_is_current
!= w2_is_current
)
5798 /* Verify that the corresponding windows do match. */
5799 if (! EQ (p1
->buffer
, p2
->buffer
))
5801 if (! EQ (p1
->left
, p2
->left
))
5803 if (! EQ (p1
->top
, p2
->top
))
5805 if (! EQ (p1
->width
, p2
->width
))
5807 if (! EQ (p1
->height
, p2
->height
))
5809 if (! EQ (p1
->display_table
, p2
->display_table
))
5811 if (! EQ (p1
->parent
, p2
->parent
))
5813 if (! EQ (p1
->prev
, p2
->prev
))
5815 if (! ignore_positions
)
5817 if (! EQ (p1
->hscroll
, p2
->hscroll
))
5819 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
5821 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
5823 if (NILP (Fequal (p1
->start
, p2
->start
)))
5825 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
5827 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
5835 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
5836 Scompare_window_configurations
, 2, 2, 0,
5837 doc
: /* Compare two window configurations as regards the structure of windows.
5838 This function ignores details such as the values of point and mark
5839 and scrolling positions. */)
5843 if (compare_window_configurations (x
, y
, 1))
5851 struct frame
*f
= make_terminal_frame ();
5852 XSETFRAME (selected_frame
, f
);
5853 Vterminal_frame
= selected_frame
;
5854 minibuf_window
= f
->minibuffer_window
;
5855 selected_window
= f
->selected_window
;
5856 last_nonminibuf_frame
= f
;
5858 window_initialized
= 1;
5864 Vwindow_list
= Qnil
;
5870 Qwindow_size_fixed
= intern ("window-size-fixed");
5871 staticpro (&Qwindow_size_fixed
);
5873 staticpro (&Qwindow_configuration_change_hook
);
5874 Qwindow_configuration_change_hook
5875 = intern ("window-configuration-change-hook");
5877 Qwindowp
= intern ("windowp");
5878 staticpro (&Qwindowp
);
5880 Qwindow_configuration_p
= intern ("window-configuration-p");
5881 staticpro (&Qwindow_configuration_p
);
5883 Qwindow_live_p
= intern ("window-live-p");
5884 staticpro (&Qwindow_live_p
);
5886 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
5887 staticpro (&Qtemp_buffer_show_hook
);
5889 staticpro (&Vwindow_list
);
5891 minibuf_selected_window
= Qnil
;
5892 staticpro (&minibuf_selected_window
);
5894 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
5895 doc
: /* Non-nil means call as function to display a help buffer.
5896 The function is called with one argument, the buffer to be displayed.
5897 Used by `with-output-to-temp-buffer'.
5898 If this function is used, then it must do the entire job of showing
5899 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
5900 Vtemp_buffer_show_function
= Qnil
;
5902 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
5903 doc
: /* If non-nil, function to call to handle `display-buffer'.
5904 It will receive two args, the buffer and a flag which if non-nil means
5905 that the currently selected window is not acceptable.
5906 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
5907 work using this function. */);
5908 Vdisplay_buffer_function
= Qnil
;
5910 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
5911 doc
: /* *If non-nil, `display-buffer' should even the window heights.
5912 If nil, `display-buffer' will leave the window configuration alone. */);
5913 Veven_window_heights
= Qt
;
5915 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
5916 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
5917 Vminibuf_scroll_window
= Qnil
;
5919 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
5920 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
5921 If the minibuffer is active, the `minibuffer-scroll-window' mode line
5922 is displayed in the `mode-line' face. */);
5923 mode_line_in_non_selected_windows
= 1;
5925 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
5926 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
5927 Vother_window_scroll_buffer
= Qnil
;
5929 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
5930 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
5933 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
5934 doc
: /* *Non-nil means `display-buffer' should reuse frames.
5935 If the buffer in question is already displayed in a frame, raise that frame. */);
5936 display_buffer_reuse_frames
= 0;
5938 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
5939 doc
: /* Function to call to handle automatic new frame creation.
5940 It is called with no arguments and should return a newly created frame.
5942 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
5943 where `pop-up-frame-alist' would hold the default frame parameters. */);
5944 Vpop_up_frame_function
= Qnil
;
5946 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
5947 doc
: /* *List of buffer names that should have their own special frames.
5948 Displaying a buffer whose name is in this list makes a special frame for it
5949 using `special-display-function'. See also `special-display-regexps'.
5951 An element of the list can be a list instead of just a string.
5952 There are two ways to use a list as an element:
5953 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
5954 In the first case, FRAME-PARAMETERS are used to create the frame.
5955 In the latter case, FUNCTION is called with BUFFER as the first argument,
5956 followed by OTHER-ARGS--it can display BUFFER in any way it likes.
5957 All this is done by the function found in `special-display-function'.
5959 If this variable appears \"not to work\", because you add a name to it
5960 but that buffer still appears in the selected window, look at the
5961 values of `same-window-buffer-names' and `same-window-regexps'.
5962 Those variables take precedence over this one. */);
5963 Vspecial_display_buffer_names
= Qnil
;
5965 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
5966 doc
: /* *List of regexps saying which buffers should have their own special frames.
5967 If a buffer name matches one of these regexps, it gets its own frame.
5968 Displaying a buffer whose name is in this list makes a special frame for it
5969 using `special-display-function'.
5971 An element of the list can be a list instead of just a string.
5972 There are two ways to use a list as an element:
5973 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
5974 In the first case, FRAME-PARAMETERS are used to create the frame.
5975 In the latter case, FUNCTION is called with the buffer as first argument,
5976 followed by OTHER-ARGS--it can display the buffer in any way it likes.
5977 All this is done by the function found in `special-display-function'.
5979 If this variable appears \"not to work\", because you add a regexp to it
5980 but the matching buffers still appear in the selected window, look at the
5981 values of `same-window-buffer-names' and `same-window-regexps'.
5982 Those variables take precedence over this one. */);
5983 Vspecial_display_regexps
= Qnil
;
5985 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
5986 doc
: /* Function to call to make a new frame for a special buffer.
5987 It is called with two arguments, the buffer and optional buffer specific
5988 data, and should return a window displaying that buffer.
5989 The default value normally makes a separate frame for the buffer,
5990 using `special-display-frame-alist' to specify the frame parameters.
5991 But if the buffer specific data includes (same-buffer . t) then the
5992 buffer is displayed in the current selected window.
5993 Otherwise if it includes (same-frame . t) then the buffer is displayed in
5994 a new window in the currently selected frame.
5996 A buffer is special if it is listed in `special-display-buffer-names'
5997 or matches a regexp in `special-display-regexps'. */);
5998 Vspecial_display_function
= Qnil
;
6000 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
6001 doc
: /* *List of buffer names that should appear in the selected window.
6002 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
6003 switches to it in the selected window, rather than making it appear
6004 in some other window.
6006 An element of the list can be a cons cell instead of just a string.
6007 Then the car must be a string, which specifies the buffer name.
6008 This is for compatibility with `special-display-buffer-names';
6009 the cdr of the cons cell is ignored.
6011 See also `same-window-regexps'. */);
6012 Vsame_window_buffer_names
= Qnil
;
6014 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
6015 doc
: /* *List of regexps saying which buffers should appear in the selected window.
6016 If a buffer name matches one of these regexps, then displaying it
6017 using `display-buffer' or `pop-to-buffer' switches to it
6018 in the selected window, rather than making it appear in some other window.
6020 An element of the list can be a cons cell instead of just a string.
6021 Then the car must be a string, which specifies the buffer name.
6022 This is for compatibility with `special-display-buffer-names';
6023 the cdr of the cons cell is ignored.
6025 See also `same-window-buffer-names'. */);
6026 Vsame_window_regexps
= Qnil
;
6028 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
6029 doc
: /* *Non-nil means display-buffer should make new windows. */);
6032 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
6033 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
6034 next_screen_context_lines
= 2;
6036 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
6037 doc
: /* *display-buffer would prefer to split the largest window if this large.
6038 If there is only one window, it is split regardless of this value. */);
6039 split_height_threshold
= 500;
6041 DEFVAR_INT ("window-min-height", &window_min_height
,
6042 doc
: /* *Delete any window less than this tall (including its mode line). */);
6043 window_min_height
= 4;
6045 DEFVAR_INT ("window-min-width", &window_min_width
,
6046 doc
: /* *Delete any window less than this wide. */);
6047 window_min_width
= 10;
6049 DEFVAR_LISP ("scroll-preserve-screen-position",
6050 &Vscroll_preserve_screen_position
,
6051 doc
: /* *Non-nil means scroll commands move point to keep its screen line unchanged. */);
6052 Vscroll_preserve_screen_position
= Qnil
;
6054 DEFVAR_LISP ("window-configuration-change-hook",
6055 &Vwindow_configuration_change_hook
,
6056 doc
: /* Functions to call when window configuration changes.
6057 The selected frame is the one whose configuration has changed. */);
6058 Vwindow_configuration_change_hook
= Qnil
;
6060 DEFVAR_BOOL ("window-size-fixed", &window_size_fixed
,
6061 doc
: /* Non-nil in a buffer means windows displaying the buffer are fixed-size.
6062 Emacs won't change the size of any window displaying that buffer,
6063 unless you explicitly change the size, or Emacs has no other choice.
6064 This variable automatically becomes buffer-local when set. */);
6065 Fmake_variable_buffer_local (Qwindow_size_fixed
);
6066 window_size_fixed
= 0;
6068 defsubr (&Sselected_window
);
6069 defsubr (&Sminibuffer_window
);
6070 defsubr (&Swindow_minibuffer_p
);
6071 defsubr (&Swindowp
);
6072 defsubr (&Swindow_live_p
);
6073 defsubr (&Spos_visible_in_window_p
);
6074 defsubr (&Swindow_buffer
);
6075 defsubr (&Swindow_height
);
6076 defsubr (&Swindow_width
);
6077 defsubr (&Swindow_hscroll
);
6078 defsubr (&Sset_window_hscroll
);
6079 defsubr (&Swindow_redisplay_end_trigger
);
6080 defsubr (&Sset_window_redisplay_end_trigger
);
6081 defsubr (&Swindow_edges
);
6082 defsubr (&Scoordinates_in_window_p
);
6083 defsubr (&Swindow_at
);
6084 defsubr (&Swindow_point
);
6085 defsubr (&Swindow_start
);
6086 defsubr (&Swindow_end
);
6087 defsubr (&Sset_window_point
);
6088 defsubr (&Sset_window_start
);
6089 defsubr (&Swindow_dedicated_p
);
6090 defsubr (&Sset_window_dedicated_p
);
6091 defsubr (&Swindow_display_table
);
6092 defsubr (&Sset_window_display_table
);
6093 defsubr (&Snext_window
);
6094 defsubr (&Sprevious_window
);
6095 defsubr (&Sother_window
);
6096 defsubr (&Sget_lru_window
);
6097 defsubr (&Sget_largest_window
);
6098 defsubr (&Sget_buffer_window
);
6099 defsubr (&Sdelete_other_windows
);
6100 defsubr (&Sdelete_windows_on
);
6101 defsubr (&Sreplace_buffer_in_windows
);
6102 defsubr (&Sdelete_window
);
6103 defsubr (&Sset_window_buffer
);
6104 defsubr (&Sselect_window
);
6105 defsubr (&Sspecial_display_p
);
6106 defsubr (&Ssame_window_p
);
6107 defsubr (&Sdisplay_buffer
);
6108 defsubr (&Ssplit_window
);
6109 defsubr (&Senlarge_window
);
6110 defsubr (&Sshrink_window
);
6111 defsubr (&Sscroll_up
);
6112 defsubr (&Sscroll_down
);
6113 defsubr (&Sscroll_left
);
6114 defsubr (&Sscroll_right
);
6115 defsubr (&Sother_window_for_scrolling
);
6116 defsubr (&Sscroll_other_window
);
6117 defsubr (&Sminibuffer_selected_window
);
6118 defsubr (&Srecenter
);
6119 defsubr (&Swindow_text_height
);
6120 defsubr (&Smove_to_window_line
);
6121 defsubr (&Swindow_configuration_p
);
6122 defsubr (&Swindow_configuration_frame
);
6123 defsubr (&Sset_window_configuration
);
6124 defsubr (&Scurrent_window_configuration
);
6125 defsubr (&Ssave_window_excursion
);
6126 defsubr (&Sset_window_margins
);
6127 defsubr (&Swindow_margins
);
6128 defsubr (&Swindow_vscroll
);
6129 defsubr (&Sset_window_vscroll
);
6130 defsubr (&Scompare_window_configurations
);
6131 defsubr (&Swindow_list
);
6137 initial_define_key (control_x_map
, '1', "delete-other-windows");
6138 initial_define_key (control_x_map
, '2', "split-window");
6139 initial_define_key (control_x_map
, '0', "delete-window");
6140 initial_define_key (control_x_map
, 'o', "other-window");
6141 initial_define_key (control_x_map
, '^', "enlarge-window");
6142 initial_define_key (control_x_map
, '<', "scroll-left");
6143 initial_define_key (control_x_map
, '>', "scroll-right");
6145 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
6146 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6147 initial_define_key (meta_map
, 'v', "scroll-down");
6149 initial_define_key (global_map
, Ctl('L'), "recenter");
6150 initial_define_key (meta_map
, 'r', "move-to-window-line");