1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
36 #include "dispextern.h"
37 #include "blockinput.h"
38 #include "intervals.h"
39 #include "termhooks.h" /* For FRAME_TERMINAL. */
44 #endif /* HAVE_X_WINDOWS */
56 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
57 Lisp_Object Qdisplay_buffer
;
58 Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
59 Lisp_Object Qwindow_size_fixed
;
61 static int displayed_window_lines (struct window
*);
62 static struct window
*decode_window (Lisp_Object
);
63 static int count_windows (struct window
*);
64 static int get_leaf_windows (struct window
*, struct window
**, int);
65 static void window_scroll (Lisp_Object
, int, int, int);
66 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
67 static void window_scroll_line_based (Lisp_Object
, int, int, int);
68 static int window_min_size_1 (struct window
*, int, int);
69 static int window_min_size_2 (struct window
*, int, int);
70 static int window_min_size (struct window
*, int, int, int, int *);
71 static void size_window (Lisp_Object
, int, int, int, int, int);
72 static int freeze_window_start (struct window
*, void *);
73 static int window_fixed_size_p (struct window
*, int, int);
74 static void enlarge_window (Lisp_Object
, int, int);
75 static Lisp_Object
window_list (void);
76 static int add_window_to_list (struct window
*, void *);
77 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
79 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
81 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
83 static int foreach_window_1 (struct window
*,
84 int (* fn
) (struct window
*, void *),
86 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
88 /* This is the window in which the terminal's cursor should
89 be left when nothing is being done with it. This must
90 always be a leaf window, and its buffer is selected by
91 the top level editing loop at the end of each command.
93 This value is always the same as
94 FRAME_SELECTED_WINDOW (selected_frame). */
96 Lisp_Object selected_window
;
98 /* A list of all windows for use by next_window and Fwindow_list.
99 Functions creating or deleting windows should invalidate this cache
100 by setting it to nil. */
102 Lisp_Object Vwindow_list
;
104 /* The mini-buffer window of the selected frame.
105 Note that you cannot test for mini-bufferness of an arbitrary window
106 by comparing against this; but you can test for mini-bufferness of
107 the selected window. */
109 Lisp_Object minibuf_window
;
111 /* Non-nil means it is the window whose mode line should be
112 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Non-nil means it is the window for C-M-v to scroll
117 when the mini-buffer is selected. */
119 Lisp_Object Vminibuf_scroll_window
;
121 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
123 Lisp_Object Vother_window_scroll_buffer
;
125 /* Non-nil means it's function to call to display temp buffers. */
127 Lisp_Object Vtemp_buffer_show_function
;
129 /* Non-zero means line and page scrolling on tall lines (with images)
130 does partial scrolling by modifying window-vscroll. */
132 int auto_window_vscroll_p
;
134 /* Non-zero means to use mode-line-inactive face in all windows but the
135 selected-window and the minibuffer-scroll-window when the
136 minibuffer is active. */
137 int mode_line_in_non_selected_windows
;
139 /* If a window gets smaller than either of these, it is removed. */
141 EMACS_INT window_min_height
;
142 EMACS_INT window_min_width
;
144 /* Hook run at end of temp_output_buffer_show. */
146 Lisp_Object Qtemp_buffer_show_hook
;
148 /* Number of lines of continuity in scrolling by screenfuls. */
150 EMACS_INT next_screen_context_lines
;
152 /* Incremented for each window created. */
154 static int sequence_number
;
156 /* Nonzero after init_window_once has finished. */
158 static int window_initialized
;
160 /* Hook to run when window config changes. */
162 static Lisp_Object Qwindow_configuration_change_hook
;
163 static Lisp_Object Vwindow_configuration_change_hook
;
165 /* Non-nil means scroll commands try to put point
166 at the same screen height as previously. */
168 Lisp_Object Vscroll_preserve_screen_position
;
170 /* Non-nil means that text is inserted before window's markers. */
172 Lisp_Object Vwindow_point_insertion_type
;
174 /* Incremented by 1 whenever a window is deleted. */
176 int window_deletion_count
;
178 /* Used by the function window_scroll_pixel_based */
180 static int window_scroll_pixel_based_preserve_x
;
181 static int window_scroll_pixel_based_preserve_y
;
183 /* Same for window_scroll_line_based. */
185 static int window_scroll_preserve_hpos
;
186 static int window_scroll_preserve_vpos
;
188 #if 0 /* This isn't used anywhere. */
189 /* Nonzero means we can split a frame even if it is "unsplittable". */
190 static int inhibit_frame_unsplittable
;
193 /* If non-nil, then the `recenter' command with a nil argument
194 the entire frame to be redrawn; the special value `tty' causes the
195 frame to be redrawn only if it is a tty frame. */
197 static Lisp_Object Vrecenter_redisplay
;
200 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
201 doc
: /* Return t if OBJECT is a window. */)
204 return WINDOWP (object
) ? Qt
: Qnil
;
207 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
208 doc
: /* Return t if OBJECT is a window which is currently visible. */)
211 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
218 register struct window
*p
;
220 p
= allocate_window ();
222 XSETFASTINT (p
->sequence_number
, sequence_number
);
223 XSETFASTINT (p
->left_col
, 0);
224 XSETFASTINT (p
->top_line
, 0);
225 XSETFASTINT (p
->total_lines
, 0);
226 XSETFASTINT (p
->total_cols
, 0);
227 XSETFASTINT (p
->hscroll
, 0);
228 XSETFASTINT (p
->min_hscroll
, 0);
229 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
230 p
->start
= Fmake_marker ();
231 p
->pointm
= Fmake_marker ();
232 XSETFASTINT (p
->use_time
, 0);
234 p
->display_table
= Qnil
;
236 p
->window_parameters
= Qnil
;
237 p
->pseudo_window_p
= 0;
238 memset (&p
->cursor
, 0, sizeof (p
->cursor
));
239 memset (&p
->last_cursor
, 0, sizeof (p
->last_cursor
));
240 memset (&p
->phys_cursor
, 0, sizeof (p
->phys_cursor
));
241 p
->desired_matrix
= p
->current_matrix
= 0;
242 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
243 p
->phys_cursor_type
= -1;
244 p
->phys_cursor_width
= -1;
245 p
->must_be_updated_p
= 0;
246 XSETFASTINT (p
->window_end_vpos
, 0);
247 XSETFASTINT (p
->window_end_pos
, 0);
248 p
->window_end_valid
= Qnil
;
251 XSETFASTINT (p
->last_point
, 0);
252 p
->frozen_window_start_p
= 0;
253 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
254 p
->left_margin_cols
= Qnil
;
255 p
->right_margin_cols
= Qnil
;
256 p
->left_fringe_width
= Qnil
;
257 p
->right_fringe_width
= Qnil
;
258 p
->fringes_outside_margins
= Qnil
;
259 p
->scroll_bar_width
= Qnil
;
260 p
->vertical_scroll_bar_type
= Qt
;
261 p
->resize_proportionally
= Qnil
;
267 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
268 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
271 return selected_window
;
274 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
275 doc
: /* Return the window used now for minibuffers.
276 If the optional argument FRAME is specified, return the minibuffer window
277 used by that frame. */)
281 frame
= selected_frame
;
282 CHECK_LIVE_FRAME (frame
);
283 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
286 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
287 doc
: /* Return non-nil if WINDOW is a minibuffer window.
288 WINDOW defaults to the selected window. */)
291 struct window
*w
= decode_window (window
);
292 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
296 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
297 Spos_visible_in_window_p
, 0, 3, 0,
298 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
299 Return nil if that position is scrolled vertically out of view.
300 If a character is only partially visible, nil is returned, unless the
301 optional argument PARTIALLY is non-nil.
302 If POS is only out of view because of horizontal scrolling, return non-nil.
303 If POS is t, it specifies the position of the last visible glyph in WINDOW.
304 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
306 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
307 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
308 where X and Y are the pixel coordinates relative to the top left corner
309 of the window. The remaining elements are omitted if the character after
310 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
311 off-window at the top and bottom of the row, ROWH is the height of the
312 display row, and VPOS is the row number (0-based) containing POS. */)
313 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
315 register struct window
*w
;
317 register struct buffer
*buf
;
319 Lisp_Object in_window
= Qnil
;
320 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
323 w
= decode_window (window
);
324 buf
= XBUFFER (w
->buffer
);
325 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
329 else if (!NILP (pos
))
331 CHECK_NUMBER_COERCE_MARKER (pos
);
334 else if (w
== XWINDOW (selected_window
))
337 posint
= XMARKER (w
->pointm
)->charpos
;
339 /* If position is above window start or outside buffer boundaries,
340 or if window start is out of range, position is not visible. */
342 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
343 && CHARPOS (top
) >= BUF_BEGV (buf
)
344 && CHARPOS (top
) <= BUF_ZV (buf
)
345 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
346 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
349 if (!NILP (in_window
) && !NILP (partially
))
351 Lisp_Object part
= Qnil
;
353 part
= list4 (make_number (rtop
), make_number (rbot
),
354 make_number (rowh
), make_number (vpos
));
355 in_window
= Fcons (make_number (x
),
356 Fcons (make_number (y
), part
));
362 DEFUN ("window-line-height", Fwindow_line_height
,
363 Swindow_line_height
, 0, 2, 0,
364 doc
: /* Return height in pixels of text line LINE in window WINDOW.
365 If WINDOW is nil or omitted, use selected window.
367 Return height of current line if LINE is omitted or nil. Return height of
368 header or mode line if LINE is `header-line' and `mode-line'.
369 Otherwise, LINE is a text line number starting from 0. A negative number
370 counts from the end of the window.
372 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
373 in pixels of the visible part of the line, VPOS and YPOS are the
374 vertical position in lines and pixels of the line, relative to the top
375 of the first text line, and OFFBOT is the number of off-window pixels at
376 the bottom of the text line. If there are off-window pixels at the top
377 of the (first) text line, YPOS is negative.
379 Return nil if window display is not up-to-date. In that case, use
380 `pos-visible-in-window-p' to obtain the information. */)
381 (Lisp_Object line
, Lisp_Object window
)
383 register struct window
*w
;
384 register struct buffer
*b
;
385 struct glyph_row
*row
, *end_row
;
386 int max_y
, crop
, i
, n
;
388 w
= decode_window (window
);
391 || w
->pseudo_window_p
)
394 CHECK_BUFFER (w
->buffer
);
395 b
= XBUFFER (w
->buffer
);
397 /* Fail if current matrix is not up-to-date. */
398 if (NILP (w
->window_end_valid
)
399 || current_buffer
->clip_changed
400 || current_buffer
->prevent_redisplay_optimizations_p
401 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
402 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
408 if (i
< 0 || i
>= w
->current_matrix
->nrows
409 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
411 max_y
= window_text_bottom_y (w
);
415 if (EQ (line
, Qheader_line
))
417 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
419 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
422 return list4 (make_number (row
->height
),
423 make_number (0), make_number (0),
427 if (EQ (line
, Qmode_line
))
429 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
432 return list4 (make_number (row
->height
),
433 make_number (0), /* not accurate */
434 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
435 + window_text_bottom_y (w
)),
442 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
443 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
444 max_y
= window_text_bottom_y (w
);
447 while ((n
< 0 || i
< n
)
448 && row
<= end_row
&& row
->enabled_p
449 && row
->y
+ row
->height
< max_y
)
452 if (row
> end_row
|| !row
->enabled_p
)
464 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
465 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
467 make_number (row
->y
),
473 static struct window
*
474 decode_window (register Lisp_Object window
)
477 return XWINDOW (selected_window
);
479 CHECK_LIVE_WINDOW (window
);
480 return XWINDOW (window
);
483 static struct window
*
484 decode_any_window (register Lisp_Object window
)
487 return XWINDOW (selected_window
);
489 CHECK_WINDOW (window
);
490 return XWINDOW (window
);
493 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
494 doc
: /* Return the buffer that WINDOW is displaying.
495 WINDOW defaults to the selected window. */)
498 return decode_window (window
)->buffer
;
501 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
502 doc
: /* Return the number of lines in WINDOW.
503 WINDOW defaults to the selected window.
505 The return value includes WINDOW's mode line and header line, if any.
507 Note: The function does not take into account the value of `line-spacing'
508 when calculating the number of lines in WINDOW. */)
511 return decode_any_window (window
)->total_lines
;
514 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
515 doc
: /* Return the number of display columns in WINDOW.
516 WINDOW defaults to the selected window.
518 Note: The return value is the number of columns available for text in
519 WINDOW. If you want to find out how many columns WINDOW takes up, use
520 (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
523 return make_number (window_box_text_cols (decode_any_window (window
)));
526 DEFUN ("window-full-width-p", Fwindow_full_width_p
, Swindow_full_width_p
, 0, 1, 0,
527 doc
: /* Return t if WINDOW is as wide as its frame.
528 WINDOW defaults to the selected window. */)
531 return WINDOW_FULL_WIDTH_P (decode_any_window (window
)) ? Qt
: Qnil
;
534 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
535 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
536 WINDOW defaults to the selected window. */)
539 return decode_window (window
)->hscroll
;
542 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
543 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
544 Return NCOL. NCOL should be zero or positive.
546 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
547 window so that the location of point moves off-window. */)
548 (Lisp_Object window
, Lisp_Object ncol
)
550 struct window
*w
= decode_window (window
);
554 hscroll
= max (0, XINT (ncol
));
556 /* Prevent redisplay shortcuts when changing the hscroll. */
557 if (XINT (w
->hscroll
) != hscroll
)
558 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
560 w
->hscroll
= make_number (hscroll
);
564 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
565 Swindow_redisplay_end_trigger
, 0, 1, 0,
566 doc
: /* Return WINDOW's redisplay end trigger value.
567 WINDOW defaults to the selected window.
568 See `set-window-redisplay-end-trigger' for more information. */)
571 return decode_window (window
)->redisplay_end_trigger
;
574 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
575 Sset_window_redisplay_end_trigger
, 2, 2, 0,
576 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
577 VALUE should be a buffer position (typically a marker) or nil.
578 If it is a buffer position, then if redisplay in WINDOW reaches a position
579 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
580 with two arguments: WINDOW, and the end trigger value.
581 Afterwards the end-trigger value is reset to nil. */)
582 (register Lisp_Object window
, Lisp_Object value
)
584 register struct window
*w
;
586 w
= decode_window (window
);
587 w
->redisplay_end_trigger
= value
;
591 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
592 doc
: /* Return a list of the edge coordinates of WINDOW.
593 The list has the form (LEFT TOP RIGHT BOTTOM).
594 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
595 all relative to 0, 0 at top left corner of frame.
597 RIGHT is one more than the rightmost column occupied by WINDOW.
598 BOTTOM is one more than the bottommost row occupied by WINDOW.
599 The edges include the space used by WINDOW's scroll bar, display
600 margins, fringes, header line, and/or mode line. For the edges of
601 just the text area, use `window-inside-edges'. */)
604 register struct window
*w
= decode_any_window (window
);
606 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
607 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
608 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
609 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
613 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
614 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
615 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
616 the top left corner of the frame.
618 RIGHT is one more than the rightmost x position occupied by WINDOW.
619 BOTTOM is one more than the bottommost y position occupied by WINDOW.
620 The pixel edges include the space used by WINDOW's scroll bar, display
621 margins, fringes, header line, and/or mode line. For the pixel edges
622 of just the text area, use `window-inside-pixel-edges'. */)
625 register struct window
*w
= decode_any_window (window
);
627 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
628 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
629 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
630 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
635 calc_absolute_offset(struct window
*w
, int *add_x
, int *add_y
)
637 struct frame
*f
= XFRAME (w
->frame
);
639 #ifdef FRAME_MENUBAR_HEIGHT
640 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
642 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
643 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
644 #elif FRAME_TOOLBAR_HEIGHT
645 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
647 #ifdef FRAME_NS_TITLEBAR_HEIGHT
648 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
650 *add_x
= f
->left_pos
;
651 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
652 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
656 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
657 Swindow_absolute_pixel_edges
, 0, 1, 0,
658 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
659 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
660 the top left corner of the display.
662 RIGHT is one more than the rightmost x position occupied by WINDOW.
663 BOTTOM is one more than the bottommost y position occupied by WINDOW.
664 The pixel edges include the space used by WINDOW's scroll bar, display
665 margins, fringes, header line, and/or mode line. For the pixel edges
666 of just the text area, use `window-inside-absolute-pixel-edges'. */)
669 register struct window
*w
= decode_any_window (window
);
671 calc_absolute_offset (w
, &add_x
, &add_y
);
673 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
674 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
675 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
676 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
680 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
681 doc
: /* Return a list of the edge coordinates of WINDOW.
682 The list has the form (LEFT TOP RIGHT BOTTOM).
683 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
684 all relative to 0, 0 at top left corner of frame.
686 RIGHT is one more than the rightmost column of WINDOW's text area.
687 BOTTOM is one more than the bottommost row of WINDOW's text area.
688 The inside edges do not include the space used by the WINDOW's scroll
689 bar, display margins, fringes, header line, and/or mode line. */)
692 register struct window
*w
= decode_any_window (window
);
694 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
695 + WINDOW_LEFT_MARGIN_COLS (w
)
696 + WINDOW_LEFT_FRINGE_COLS (w
)),
697 make_number (WINDOW_TOP_EDGE_LINE (w
)
698 + WINDOW_HEADER_LINE_LINES (w
)),
699 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
700 - WINDOW_RIGHT_MARGIN_COLS (w
)
701 - WINDOW_RIGHT_FRINGE_COLS (w
)),
702 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
703 - WINDOW_MODE_LINE_LINES (w
)));
706 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
707 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
708 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
709 the top left corner of the frame.
711 RIGHT is one more than the rightmost x position of WINDOW's text area.
712 BOTTOM is one more than the bottommost y position of WINDOW's text area.
713 The inside edges do not include the space used by WINDOW's scroll bar,
714 display margins, fringes, header line, and/or mode line. */)
717 register struct window
*w
= decode_any_window (window
);
719 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
720 + WINDOW_LEFT_MARGIN_WIDTH (w
)
721 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
722 make_number (WINDOW_TOP_EDGE_Y (w
)
723 + WINDOW_HEADER_LINE_HEIGHT (w
)),
724 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
725 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
726 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
727 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
728 - WINDOW_MODE_LINE_HEIGHT (w
)));
731 DEFUN ("window-inside-absolute-pixel-edges",
732 Fwindow_inside_absolute_pixel_edges
,
733 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
734 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
735 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
736 the top left corner of the display.
738 RIGHT is one more than the rightmost x position of WINDOW's text area.
739 BOTTOM is one more than the bottommost y position of WINDOW's text area.
740 The inside edges do not include the space used by WINDOW's scroll bar,
741 display margins, fringes, header line, and/or mode line. */)
744 register struct window
*w
= decode_any_window (window
);
746 calc_absolute_offset (w
, &add_x
, &add_y
);
748 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
749 + WINDOW_LEFT_MARGIN_WIDTH (w
)
750 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
751 make_number (WINDOW_TOP_EDGE_Y (w
)
752 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
753 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
754 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
755 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
756 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
757 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
760 /* Test if the character at column *X, row *Y is within window W.
761 If it is not, return ON_NOTHING;
762 if it is in the window's text area,
763 set *x and *y to its location relative to the upper left corner
766 if it is on the window's modeline, return ON_MODE_LINE;
767 if it is on the border between the window and its right sibling,
768 return ON_VERTICAL_BORDER.
769 if it is on a scroll bar,
770 return ON_SCROLL_BAR.
771 if it is on the window's top line, return ON_HEADER_LINE;
772 if it is in left or right fringe of the window,
773 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
774 to window-relative coordinates;
775 if it is in the marginal area to the left/right of the window,
776 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
777 to window-relative coordinates.
779 X and Y are frame relative pixel coordinates. */
781 static enum window_part
782 coordinates_in_window (register struct window
*w
, register int *x
, register int *y
)
784 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
785 int left_x
, right_x
, top_y
, bottom_y
;
786 enum window_part part
;
787 int ux
= FRAME_COLUMN_WIDTH (f
);
788 int x0
= WINDOW_LEFT_EDGE_X (w
);
789 int x1
= WINDOW_RIGHT_EDGE_X (w
);
790 /* The width of the area where the vertical line can be dragged.
791 (Between mode lines for instance. */
792 int grabbable_width
= ux
;
793 int lmargin_width
, rmargin_width
, text_left
, text_right
;
795 /* In what's below, we subtract 1 when computing right_x because we
796 want the rightmost pixel, which is given by left_pixel+width-1. */
797 if (w
->pseudo_window_p
)
800 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
801 top_y
= WINDOW_TOP_EDGE_Y (w
);
802 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
806 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
807 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
808 top_y
= WINDOW_TOP_EDGE_Y (w
);
809 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
812 /* Outside any interesting row? */
813 if (*y
< top_y
|| *y
>= bottom_y
)
816 /* On the mode line or header line? If it's near the start of
817 the mode or header line of window that's has a horizontal
818 sibling, say it's on the vertical line. That's to be able
819 to resize windows horizontally in case we're using toolkit
822 if (WINDOW_WANTS_MODELINE_P (w
)
823 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
827 header_vertical_border_check
:
828 /* We're somewhere on the mode line. We consider the place
829 between mode lines of horizontally adjacent mode lines
830 as the vertical border. If scroll bars on the left,
831 return the right window. */
832 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
833 || WINDOW_RIGHTMOST_P (w
))
835 if (!WINDOW_LEFTMOST_P (w
) && eabs (*x
- x0
) < grabbable_width
)
837 /* Convert X and Y to window relative coordinates.
838 Vertical border is at the left edge of window. */
839 *x
= max (0, *x
- x0
);
841 return ON_VERTICAL_BORDER
;
846 /* Make sure we're not at the rightmost position of a
847 mode-/header-line and there's yet another window on
848 the right. (Bug#1372) */
849 if ((WINDOW_RIGHTMOST_P (w
) || *x
< x1
)
850 && eabs (*x
- x1
) < grabbable_width
)
852 /* Convert X and Y to window relative coordinates.
853 Vertical border is at the right edge of window. */
854 *x
= min (x1
, *x
) - x0
;
856 return ON_VERTICAL_BORDER
;
860 if (*x
< x0
|| *x
>= x1
)
863 /* Convert X and Y to window relative coordinates.
864 Mode line starts at left edge of window. */
870 if (WINDOW_WANTS_HEADER_LINE_P (w
)
871 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
873 part
= ON_HEADER_LINE
;
874 goto header_vertical_border_check
;
877 if (*x
< x0
|| *x
>= x1
)
880 /* Outside any interesting column? */
881 if (*x
< left_x
|| *x
> right_x
)
884 return ON_SCROLL_BAR
;
887 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
888 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
890 text_left
= window_box_left (w
, TEXT_AREA
);
891 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
893 if (FRAME_WINDOW_P (f
))
895 if (!w
->pseudo_window_p
896 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
897 && !WINDOW_RIGHTMOST_P (w
)
898 && (eabs (*x
- right_x
) < grabbable_width
))
900 /* Convert X and Y to window relative coordinates.
901 Vertical border is at the right edge of window. */
902 *x
= min (right_x
, *x
) - left_x
;
904 return ON_VERTICAL_BORDER
;
909 /* Need to say "*x > right_x" rather than >=, since on character
910 terminals, the vertical line's x coordinate is right_x. */
911 if (!w
->pseudo_window_p
912 && !WINDOW_RIGHTMOST_P (w
)
913 && *x
> right_x
- ux
)
915 /* On the border on the right side of the window? Assume that
916 this area begins at RIGHT_X minus a canonical char width. */
917 *x
= min (right_x
, *x
) - left_x
;
919 return ON_VERTICAL_BORDER
;
925 if (lmargin_width
> 0
926 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
927 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
928 : (*x
< left_x
+ lmargin_width
)))
931 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
932 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
934 return ON_LEFT_MARGIN
;
937 /* Convert X and Y to window-relative pixel coordinates. */
940 return ON_LEFT_FRINGE
;
943 if (*x
>= text_right
)
945 if (rmargin_width
> 0
946 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
947 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
948 : (*x
>= right_x
- rmargin_width
)))
950 *x
-= right_x
- rmargin_width
;
951 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
952 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
954 return ON_RIGHT_MARGIN
;
957 /* Convert X and Y to window-relative pixel coordinates. */
958 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
960 return ON_RIGHT_FRINGE
;
963 /* Everything special ruled out - must be on text area */
970 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
971 Scoordinates_in_window_p
, 2, 2, 0,
972 doc
: /* Return non-nil if COORDINATES are in WINDOW.
973 COORDINATES is a cons of the form (X . Y), X and Y being distances
974 measured in characters from the upper-left corner of the frame.
975 \(0 . 0) denotes the character in the upper left corner of the
977 If COORDINATES are in the text portion of WINDOW,
978 the coordinates relative to the window are returned.
979 If they are in the mode line of WINDOW, `mode-line' is returned.
980 If they are in the top mode line of WINDOW, `header-line' is returned.
981 If they are in the left fringe of WINDOW, `left-fringe' is returned.
982 If they are in the right fringe of WINDOW, `right-fringe' is returned.
983 If they are on the border between WINDOW and its right sibling,
984 `vertical-line' is returned.
985 If they are in the windows's left or right marginal areas, `left-margin'\n\
986 or `right-margin' is returned. */)
987 (register Lisp_Object coordinates
, Lisp_Object window
)
994 CHECK_WINDOW (window
);
995 w
= XWINDOW (window
);
996 f
= XFRAME (w
->frame
);
997 CHECK_CONS (coordinates
);
998 lx
= Fcar (coordinates
);
999 ly
= Fcdr (coordinates
);
1000 CHECK_NUMBER_OR_FLOAT (lx
);
1001 CHECK_NUMBER_OR_FLOAT (ly
);
1002 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1003 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1005 switch (coordinates_in_window (w
, &x
, &y
))
1011 /* X and Y are now window relative pixel coordinates. Convert
1012 them to canonical char units before returning them. */
1013 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1014 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1019 case ON_VERTICAL_BORDER
:
1020 return Qvertical_line
;
1022 case ON_HEADER_LINE
:
1023 return Qheader_line
;
1025 case ON_LEFT_FRINGE
:
1026 return Qleft_fringe
;
1028 case ON_RIGHT_FRINGE
:
1029 return Qright_fringe
;
1031 case ON_LEFT_MARGIN
:
1032 return Qleft_margin
;
1034 case ON_RIGHT_MARGIN
:
1035 return Qright_margin
;
1038 /* Historically we are supposed to return nil in this case. */
1047 /* Callback for foreach_window, used in window_from_coordinates.
1048 Check if window W contains coordinates specified by USER_DATA which
1049 is actually a pointer to a struct check_window_data CW.
1051 Check if window W contains coordinates *CW->x and *CW->y. If it
1052 does, return W in *CW->window, as Lisp_Object, and return in
1053 *CW->part the part of the window under coordinates *X,*Y. Return
1054 zero from this function to stop iterating over windows. */
1056 struct check_window_data
1058 Lisp_Object
*window
;
1060 enum window_part
*part
;
1064 check_window_containing (struct window
*w
, void *user_data
)
1066 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1067 enum window_part found
;
1070 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1071 if (found
!= ON_NOTHING
)
1074 XSETWINDOW (*cw
->window
, w
);
1082 /* Find the window containing frame-relative pixel position X/Y and
1083 return it as a Lisp_Object.
1085 If X, Y is on one of the window's special `window_part' elements,
1086 set *PART to the id of that element, and return X and Y converted
1087 to window relative coordinates in WX and WY.
1089 If there is no window under X, Y return nil and leave *PART
1090 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1092 This function was previously implemented with a loop cycling over
1093 windows with Fnext_window, and starting with the frame's selected
1094 window. It turned out that this doesn't work with an
1095 implementation of next_window using Vwindow_list, because
1096 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1097 tree of F when this function is called asynchronously from
1098 note_mouse_highlight. The original loop didn't terminate in this
1102 window_from_coordinates (struct frame
*f
, int x
, int y
, enum window_part
*part
, int *wx
, int *wy
, int tool_bar_p
)
1105 struct check_window_data cw
;
1106 enum window_part dummy
;
1112 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1113 foreach_window (f
, check_window_containing
, &cw
);
1115 /* If not found above, see if it's in the tool bar window, if a tool
1119 && WINDOWP (f
->tool_bar_window
)
1120 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1121 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1125 window
= f
->tool_bar_window
;
1134 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1135 doc
: /* Return window containing coordinates X and Y on FRAME.
1136 If omitted, FRAME defaults to the currently selected frame.
1137 The top left corner of the frame is considered to be row 0,
1139 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1144 frame
= selected_frame
;
1145 CHECK_LIVE_FRAME (frame
);
1148 /* Check that arguments are integers or floats. */
1149 CHECK_NUMBER_OR_FLOAT (x
);
1150 CHECK_NUMBER_OR_FLOAT (y
);
1152 return window_from_coordinates (f
,
1153 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1154 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1155 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1156 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1160 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1161 doc
: /* Return current value of point in WINDOW.
1162 WINDOW defaults to the selected window.
1164 For a nonselected window, this is the value point would have
1165 if that window were selected.
1167 Note that, when WINDOW is the selected window and its buffer
1168 is also currently selected, the value returned is the same as (point).
1169 It would be more strictly correct to return the `top-level' value
1170 of point, outside of any save-excursion forms.
1171 But that is hard to define. */)
1172 (Lisp_Object window
)
1174 register struct window
*w
= decode_window (window
);
1176 if (w
== XWINDOW (selected_window
)
1177 && current_buffer
== XBUFFER (w
->buffer
))
1179 return Fmarker_position (w
->pointm
);
1182 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1183 doc
: /* Return position at which display currently starts in WINDOW.
1184 WINDOW defaults to the selected window.
1185 This is updated by redisplay or by calling `set-window-start'. */)
1186 (Lisp_Object window
)
1188 return Fmarker_position (decode_window (window
)->start
);
1191 /* This is text temporarily removed from the doc string below.
1193 This function returns nil if the position is not currently known.
1194 That happens when redisplay is preempted and doesn't finish.
1195 If in that case you want to compute where the end of the window would
1196 have been if redisplay had finished, do this:
1198 (goto-char (window-start window))
1199 (vertical-motion (1- (window-height window)) window)
1202 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1203 doc
: /* Return position at which display currently ends in WINDOW.
1204 WINDOW defaults to the selected window.
1205 This is updated by redisplay, when it runs to completion.
1206 Simply changing the buffer text or setting `window-start'
1207 does not update this value.
1208 Return nil if there is no recorded value. \(This can happen if the
1209 last redisplay of WINDOW was preempted, and did not finish.)
1210 If UPDATE is non-nil, compute the up-to-date position
1211 if it isn't already recorded. */)
1212 (Lisp_Object window
, Lisp_Object update
)
1215 struct window
*w
= decode_window (window
);
1223 #if 0 /* This change broke some things. We should make it later. */
1224 /* If we don't know the end position, return nil.
1225 The user can compute it with vertical-motion if he wants to.
1226 It would be nicer to do it automatically,
1227 but that's so slow that it would probably bother people. */
1228 if (NILP (w
->window_end_valid
))
1233 && ! (! NILP (w
->window_end_valid
)
1234 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1235 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1238 struct text_pos startp
;
1240 struct buffer
*old_buffer
= NULL
;
1242 /* Cannot use Fvertical_motion because that function doesn't
1243 cope with variable-height lines. */
1244 if (b
!= current_buffer
)
1246 old_buffer
= current_buffer
;
1247 set_buffer_internal (b
);
1250 /* In case W->start is out of the range, use something
1251 reasonable. This situation occurred when loading a file with
1252 `-l' containing a call to `rmail' with subsequent other
1253 commands. At the end, W->start happened to be BEG, while
1254 rmail had already narrowed the buffer. */
1255 if (XMARKER (w
->start
)->charpos
< BEGV
)
1256 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1257 else if (XMARKER (w
->start
)->charpos
> ZV
)
1258 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1260 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1262 start_display (&it
, w
, startp
);
1263 move_it_vertically (&it
, window_box_height (w
));
1264 if (it
.current_y
< it
.last_visible_y
)
1265 move_it_past_eol (&it
);
1266 value
= make_number (IT_CHARPOS (it
));
1269 set_buffer_internal (old_buffer
);
1272 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1277 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1278 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1280 (Lisp_Object window
, Lisp_Object pos
)
1282 register struct window
*w
= decode_window (window
);
1284 CHECK_NUMBER_COERCE_MARKER (pos
);
1285 if (w
== XWINDOW (selected_window
)
1286 && XBUFFER (w
->buffer
) == current_buffer
)
1289 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1291 /* We have to make sure that redisplay updates the window to show
1292 the new value of point. */
1293 if (!EQ (window
, selected_window
))
1294 ++windows_or_buffers_changed
;
1299 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1300 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1301 WINDOW defaults to the selected window. Return POS.
1302 Optional third arg NOFORCE non-nil inhibits next redisplay from
1303 overriding motion of point in order to display at this exact start. */)
1304 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1306 register struct window
*w
= decode_window (window
);
1308 CHECK_NUMBER_COERCE_MARKER (pos
);
1309 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1310 /* this is not right, but much easier than doing what is right. */
1311 w
->start_at_line_beg
= Qnil
;
1313 w
->force_start
= Qt
;
1314 w
->update_mode_line
= Qt
;
1315 XSETFASTINT (w
->last_modified
, 0);
1316 XSETFASTINT (w
->last_overlay_modified
, 0);
1317 if (!EQ (window
, selected_window
))
1318 windows_or_buffers_changed
++;
1324 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1326 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1327 More precisely, return the value assigned by the last call of
1328 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1329 never called with WINDOW as its argument, or the value set by that
1330 function was internally reset since its last call. WINDOW defaults to
1331 the selected window.
1333 When a window is dedicated to its buffer, `display-buffer' will refrain
1334 from displaying another buffer in it. `get-lru-window' and
1335 `get-largest-window' treat dedicated windows specially.
1336 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1337 `kill-buffer' can delete a dedicated window and the containing frame.
1339 Functions like `set-window-buffer' may change the buffer displayed by a
1340 window, unless that window is "strongly" dedicated to its buffer, that
1341 is the value returned by `window-dedicated-p' is t. */)
1342 (Lisp_Object window
)
1344 return decode_window (window
)->dedicated
;
1347 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1348 Sset_window_dedicated_p
, 2, 2, 0,
1349 doc
: /* Mark WINDOW as dedicated according to FLAG.
1350 WINDOW defaults to the selected window. FLAG non-nil means mark WINDOW
1351 as dedicated to its buffer. FLAG nil means mark WINDOW as non-dedicated.
1354 When a window is dedicated to its buffer, `display-buffer' will refrain
1355 from displaying another buffer in it. `get-lru-window' and
1356 `get-largest-window' treat dedicated windows specially.
1357 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1358 `kill-buffer' can delete a dedicated window and the containing
1361 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1362 its buffer. Functions like `set-window-buffer' may change the buffer
1363 displayed by a window, unless that window is strongly dedicated to its
1364 buffer. If and when `set-window-buffer' displays another buffer in a
1365 window, it also makes sure that the window is not marked as dedicated. */)
1366 (Lisp_Object window
, Lisp_Object flag
)
1368 register struct window
*w
= decode_window (window
);
1370 w
->dedicated
= flag
;
1371 return w
->dedicated
;
1375 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1377 doc
: /* Return the parameters of WINDOW and their values.
1378 WINDOW defaults to the selected window. The return value is a list of
1379 elements of the form (PARAMETER . VALUE). */)
1380 (Lisp_Object window
)
1382 return Fcopy_alist (decode_window (window
)->window_parameters
);
1385 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1387 doc
: /* Return WINDOW's value for PARAMETER.
1388 WINDOW defaults to the selected window. */)
1389 (Lisp_Object window
, Lisp_Object parameter
)
1393 result
= Fassq (parameter
, decode_window (window
)->window_parameters
);
1394 return CDR_SAFE (result
);
1397 DEFUN ("set-window-parameter", Fset_window_parameter
,
1398 Sset_window_parameter
, 3, 3, 0,
1399 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1400 WINDOW defaults to the selected window. Return VALUE. */)
1401 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1403 register struct window
*w
= decode_window (window
);
1404 Lisp_Object old_alist_elt
;
1406 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1407 if (NILP (old_alist_elt
))
1408 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1410 Fsetcdr (old_alist_elt
, value
);
1415 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1417 doc
: /* Return the display-table that WINDOW is using.
1418 WINDOW defaults to the selected window. */)
1419 (Lisp_Object window
)
1421 return decode_window (window
)->display_table
;
1424 /* Get the display table for use on window W. This is either W's
1425 display table or W's buffer's display table. Ignore the specified
1426 tables if they are not valid; if no valid table is specified,
1429 struct Lisp_Char_Table
*
1430 window_display_table (struct window
*w
)
1432 struct Lisp_Char_Table
*dp
= NULL
;
1434 if (DISP_TABLE_P (w
->display_table
))
1435 dp
= XCHAR_TABLE (w
->display_table
);
1436 else if (BUFFERP (w
->buffer
))
1438 struct buffer
*b
= XBUFFER (w
->buffer
);
1440 if (DISP_TABLE_P (b
->display_table
))
1441 dp
= XCHAR_TABLE (b
->display_table
);
1442 else if (DISP_TABLE_P (Vstandard_display_table
))
1443 dp
= XCHAR_TABLE (Vstandard_display_table
);
1449 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1450 doc
: /* Set WINDOW's display-table to TABLE. */)
1451 (register Lisp_Object window
, Lisp_Object table
)
1453 register struct window
*w
;
1455 w
= decode_window (window
);
1456 w
->display_table
= table
;
1460 /* Record info on buffer window w is displaying
1461 when it is about to cease to display that buffer. */
1463 unshow_buffer (register struct window
*w
)
1470 if (b
!= XMARKER (w
->pointm
)->buffer
)
1474 if (w
== XWINDOW (selected_window
)
1475 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1476 /* Do this except when the selected window's buffer
1477 is being removed from some other window. */
1479 /* last_window_start records the start position that this buffer
1480 had in the last window to be disconnected from it.
1481 Now that this statement is unconditional,
1482 it is possible for the buffer to be displayed in the
1483 selected window, while last_window_start reflects another
1484 window which was recently showing the same buffer.
1485 Some people might say that might be a good thing. Let's see. */
1486 b
->last_window_start
= marker_position (w
->start
);
1488 /* Point in the selected window's buffer
1489 is actually stored in that buffer, and the window's pointm isn't used.
1490 So don't clobber point in that buffer. */
1491 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1492 /* This line helps to fix Horsley's testbug.el bug. */
1493 && !(WINDOWP (b
->last_selected_window
)
1494 && w
!= XWINDOW (b
->last_selected_window
)
1495 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1496 temp_set_point_both (b
,
1497 clip_to_bounds (BUF_BEGV (b
),
1498 XMARKER (w
->pointm
)->charpos
,
1500 clip_to_bounds (BUF_BEGV_BYTE (b
),
1501 marker_byte_position (w
->pointm
),
1504 if (WINDOWP (b
->last_selected_window
)
1505 && w
== XWINDOW (b
->last_selected_window
))
1506 b
->last_selected_window
= Qnil
;
1509 /* Put replacement into the window structure in place of old. */
1511 replace_window (Lisp_Object old
, Lisp_Object replacement
)
1513 register Lisp_Object tem
;
1514 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1516 /* If OLD is its frame's root_window, then replacement is the new
1517 root_window for that frame. */
1519 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1520 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1522 p
->left_col
= o
->left_col
;
1523 p
->top_line
= o
->top_line
;
1524 p
->total_cols
= o
->total_cols
;
1525 p
->total_lines
= o
->total_lines
;
1526 p
->desired_matrix
= p
->current_matrix
= 0;
1528 memset (&p
->cursor
, 0, sizeof (p
->cursor
));
1529 memset (&p
->last_cursor
, 0, sizeof (p
->last_cursor
));
1530 memset (&p
->phys_cursor
, 0, sizeof (p
->phys_cursor
));
1531 p
->phys_cursor_type
= -1;
1532 p
->phys_cursor_width
= -1;
1533 p
->must_be_updated_p
= 0;
1534 p
->pseudo_window_p
= 0;
1535 XSETFASTINT (p
->window_end_vpos
, 0);
1536 XSETFASTINT (p
->window_end_pos
, 0);
1537 p
->window_end_valid
= Qnil
;
1538 p
->frozen_window_start_p
= 0;
1539 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1541 p
->next
= tem
= o
->next
;
1543 XWINDOW (tem
)->prev
= replacement
;
1545 p
->prev
= tem
= o
->prev
;
1547 XWINDOW (tem
)->next
= replacement
;
1549 p
->parent
= tem
= o
->parent
;
1552 if (EQ (XWINDOW (tem
)->vchild
, old
))
1553 XWINDOW (tem
)->vchild
= replacement
;
1554 if (EQ (XWINDOW (tem
)->hchild
, old
))
1555 XWINDOW (tem
)->hchild
= replacement
;
1558 /*** Here, if replacement is a vertical combination
1559 and so is its new parent, we should make replacement's
1560 children be children of that parent instead. ***/
1563 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1564 doc
: /* Remove WINDOW from its frame.
1565 WINDOW defaults to the selected window. Return nil.
1566 Signal an error when WINDOW is the only window on its frame. */)
1567 (register Lisp_Object window
)
1571 window
= selected_window
;
1573 CHECK_LIVE_WINDOW (window
);
1575 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1576 delete_window (window
);
1578 run_window_configuration_change_hook (f
);
1584 delete_window (register Lisp_Object window
)
1586 register Lisp_Object tem
, parent
, sib
;
1587 register struct window
*p
;
1588 register struct window
*par
;
1591 /* Because this function is called by other C code on non-leaf
1592 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1593 so we can't decode_window here. */
1594 CHECK_WINDOW (window
);
1595 p
= XWINDOW (window
);
1597 /* It's a no-op to delete an already-deleted window. */
1598 if (NILP (p
->buffer
)
1600 && NILP (p
->vchild
))
1605 error ("Attempt to delete minibuffer or sole ordinary window");
1606 par
= XWINDOW (parent
);
1608 windows_or_buffers_changed
++;
1609 Vwindow_list
= Qnil
;
1610 f
= XFRAME (WINDOW_FRAME (p
));
1611 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1613 /* Are we trying to delete any frame's selected window? */
1615 Lisp_Object swindow
, pwindow
;
1617 /* See if the frame's selected window is either WINDOW
1618 or any subwindow of it, by finding all that window's parents
1619 and comparing each one with WINDOW. */
1620 swindow
= FRAME_SELECTED_WINDOW (f
);
1625 while (!NILP (pwindow
))
1627 if (EQ (window
, pwindow
))
1629 pwindow
= XWINDOW (pwindow
)->parent
;
1632 /* If the window being deleted is not a parent of SWINDOW,
1633 then SWINDOW is ok as the new selected window. */
1634 if (!EQ (window
, pwindow
))
1636 /* Otherwise, try another window for SWINDOW. */
1637 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);
1639 /* If we get back to the frame's selected window,
1640 it means there was no acceptable alternative,
1641 so we cannot delete. */
1642 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1643 error ("Cannot delete window");
1646 /* If we need to change SWINDOW, do it. */
1647 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1649 /* If we're about to delete the selected window on the
1650 selected frame, then we should use Fselect_window to select
1651 the new window. On the other hand, if we're about to
1652 delete the selected window on any other frame, we shouldn't do
1653 anything but set the frame's selected_window slot. */
1654 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1655 Fselect_window (swindow
, Qnil
);
1657 FRAME_SELECTED_WINDOW (f
) = swindow
;
1661 /* Now we know we can delete this one. */
1662 window_deletion_count
++;
1665 /* tem is null for dummy parent windows
1666 (which have inferiors but not any contents themselves) */
1670 unchain_marker (XMARKER (p
->pointm
));
1671 unchain_marker (XMARKER (p
->start
));
1674 /* Free window glyph matrices. It is sure that they are allocated
1675 again when ADJUST_GLYPHS is called. Block input so that expose
1676 events and other events that access glyph matrices are not
1677 processed while we are changing them. */
1679 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1683 XWINDOW (tem
)->prev
= p
->prev
;
1687 XWINDOW (tem
)->next
= p
->next
;
1689 if (EQ (window
, par
->hchild
))
1690 par
->hchild
= p
->next
;
1691 if (EQ (window
, par
->vchild
))
1692 par
->vchild
= p
->next
;
1694 /* Find one of our siblings to give our space to. */
1698 /* If p gives its space to its next sibling, that sibling needs
1699 to have its top/left side pulled back to where p's is.
1700 set_window_{height,width} will re-position the sibling's
1703 XWINDOW (sib
)->top_line
= p
->top_line
;
1704 XWINDOW (sib
)->left_col
= p
->left_col
;
1707 /* Stretch that sibling. */
1708 if (!NILP (par
->vchild
))
1709 set_window_height (sib
,
1710 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1712 if (!NILP (par
->hchild
))
1713 set_window_width (sib
,
1714 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1717 /* If parent now has only one child,
1718 put the child into the parent's place. */
1722 if (NILP (XWINDOW (tem
)->next
)) {
1723 replace_window (parent
, tem
);
1724 par
= XWINDOW (tem
);
1727 /* Since we may be deleting combination windows, we must make sure that
1728 not only p but all its children have been marked as deleted. */
1729 if (! NILP (p
->hchild
))
1730 delete_all_subwindows (XWINDOW (p
->hchild
));
1731 else if (! NILP (p
->vchild
))
1732 delete_all_subwindows (XWINDOW (p
->vchild
));
1734 /* Mark this window as deleted. */
1735 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1737 if (! NILP (par
->parent
))
1738 par
= XWINDOW (par
->parent
);
1740 /* Check if we have a v/hchild with a v/hchild. In that case remove
1743 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1745 p
= XWINDOW (par
->vchild
);
1746 par
->vchild
= p
->vchild
;
1749 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1751 p
= XWINDOW (par
->hchild
);
1752 par
->hchild
= p
->hchild
;
1760 while (! NILP (tem
)) {
1761 XWINDOW (tem
)->parent
= p
->parent
;
1762 if (NILP (XWINDOW (tem
)->next
))
1764 tem
= XWINDOW (tem
)->next
;
1767 /* The next of the v/hchild we are removing is now the next of the
1768 last child for the v/hchild:
1769 Before v/hchild -> v/hchild -> next1 -> next2
1772 After: v/hchild -> next1 -> next2 -> next3
1774 XWINDOW (tem
)->next
= p
->next
;
1775 if (! NILP (p
->next
))
1776 XWINDOW (p
->next
)->prev
= tem
;
1778 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1782 /* Adjust glyph matrices. */
1789 /***********************************************************************
1791 ***********************************************************************/
1793 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1794 pointer. This is a callback function for foreach_window, used in
1795 function window_list. */
1798 add_window_to_list (struct window
*w
, void *user_data
)
1800 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1802 XSETWINDOW (window
, w
);
1803 *list
= Fcons (window
, *list
);
1808 /* Return a list of all windows, for use by next_window. If
1809 Vwindow_list is a list, return that list. Otherwise, build a new
1810 list, cache it in Vwindow_list, and return that. */
1815 if (!CONSP (Vwindow_list
))
1819 Vwindow_list
= Qnil
;
1820 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1822 Lisp_Object args
[2];
1824 /* We are visiting windows in canonical order, and add
1825 new windows at the front of args[1], which means we
1826 have to reverse this list at the end. */
1828 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1829 args
[0] = Vwindow_list
;
1830 args
[1] = Fnreverse (args
[1]);
1831 Vwindow_list
= Fnconc (2, args
);
1835 return Vwindow_list
;
1839 /* Value is non-zero if WINDOW satisfies the constraints given by
1840 OWINDOW, MINIBUF and ALL_FRAMES.
1842 MINIBUF t means WINDOW may be minibuffer windows.
1843 `lambda' means WINDOW may not be a minibuffer window.
1844 a window means a specific minibuffer window
1846 ALL_FRAMES t means search all frames,
1847 nil means search just current frame,
1848 `visible' means search just visible frames,
1849 0 means search visible and iconified frames,
1850 a window means search the frame that window belongs to,
1851 a frame means consider windows on that frame, only. */
1854 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
1856 struct window
*w
= XWINDOW (window
);
1857 struct frame
*f
= XFRAME (w
->frame
);
1858 int candidate_p
= 1;
1860 if (!BUFFERP (w
->buffer
))
1862 else if (MINI_WINDOW_P (w
)
1863 && (EQ (minibuf
, Qlambda
)
1864 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1866 /* If MINIBUF is `lambda' don't consider any mini-windows.
1867 If it is a window, consider only that one. */
1870 else if (EQ (all_frames
, Qt
))
1872 else if (NILP (all_frames
))
1874 xassert (WINDOWP (owindow
));
1875 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1877 else if (EQ (all_frames
, Qvisible
))
1879 FRAME_SAMPLE_VISIBILITY (f
);
1880 candidate_p
= FRAME_VISIBLE_P (f
)
1881 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1882 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1885 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1887 FRAME_SAMPLE_VISIBILITY (f
);
1888 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
1889 #ifdef HAVE_X_WINDOWS
1890 /* Yuck!! If we've just created the frame and the
1891 window-manager requested the user to place it
1892 manually, the window may still not be considered
1893 `visible'. I'd argue it should be at least
1894 something like `iconified', but don't know how to do
1896 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
1897 && !f
->output_data
.x
->has_been_visible
)
1900 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1901 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1903 else if (WINDOWP (all_frames
))
1904 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1905 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1906 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1907 else if (FRAMEP (all_frames
))
1908 candidate_p
= EQ (all_frames
, w
->frame
);
1914 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1915 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1919 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
1922 *window
= selected_window
;
1924 CHECK_LIVE_WINDOW (*window
);
1926 /* MINIBUF nil may or may not include minibuffers. Decide if it
1928 if (NILP (*minibuf
))
1929 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1930 else if (!EQ (*minibuf
, Qt
))
1933 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1934 => count none of them, or a specific minibuffer window (the
1935 active one) to count. */
1937 /* ALL_FRAMES nil doesn't specify which frames to include. */
1938 if (NILP (*all_frames
))
1939 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1940 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1942 else if (EQ (*all_frames
, Qvisible
))
1944 else if (EQ (*all_frames
, make_number (0)))
1946 else if (FRAMEP (*all_frames
))
1948 else if (!EQ (*all_frames
, Qt
))
1951 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1952 search just current frame, `visible' meaning search just visible
1953 frames, 0 meaning search visible and iconified frames, or a
1954 window, meaning search the frame that window belongs to, or a
1955 frame, meaning consider windows on that frame, only. */
1959 /* Return the next or previous window of WINDOW in cyclic ordering
1960 of windows. NEXT_P non-zero means return the next window. See the
1961 documentation string of next-window for the meaning of MINIBUF and
1965 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
1967 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1969 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1970 return the first window on the frame. */
1971 if (FRAMEP (all_frames
)
1972 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1973 return Fframe_first_window (all_frames
);
1979 /* Find WINDOW in the list of all windows. */
1980 list
= Fmemq (window
, window_list ());
1982 /* Scan forward from WINDOW to the end of the window list. */
1984 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1985 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1988 /* Scan from the start of the window list up to WINDOW. */
1990 for (list
= Vwindow_list
;
1991 CONSP (list
) && !EQ (XCAR (list
), window
);
1993 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1997 window
= XCAR (list
);
2001 Lisp_Object candidate
, list
;
2003 /* Scan through the list of windows for candidates. If there are
2004 candidate windows in front of WINDOW, the last one of these
2005 is the one we want. If there are candidates following WINDOW
2006 in the list, again the last one of these is the one we want. */
2008 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2010 if (EQ (XCAR (list
), window
))
2012 if (WINDOWP (candidate
))
2015 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2017 candidate
= XCAR (list
);
2020 if (WINDOWP (candidate
))
2028 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2029 doc
: /* Return window following WINDOW in cyclic ordering of windows.
2030 WINDOW defaults to the selected window. The optional arguments
2031 MINIBUF and ALL-FRAMES specify the set of windows to consider.
2033 MINIBUF t means consider the minibuffer window even if the
2034 minibuffer is not active. MINIBUF nil or omitted means consider
2035 the minibuffer window only if the minibuffer is active. Any
2036 other value means do not consider the minibuffer window even if
2037 the minibuffer is active.
2039 Several frames may share a single minibuffer; if the minibuffer
2040 is active, all windows on all frames that share that minibuffer
2041 are considered too. Therefore, if you are using a separate
2042 minibuffer frame and the minibuffer is active and MINIBUF says it
2043 counts, `next-window' considers the windows in the frame from
2044 which you entered the minibuffer, as well as the minibuffer
2047 ALL-FRAMES nil or omitted means consider all windows on WINDOW's
2048 frame, plus the minibuffer window if specified by the MINIBUF
2049 argument, see above. If the minibuffer counts, consider all
2050 windows on all frames that share that minibuffer too.
2051 ALL-FRAMES t means consider all windows on all existing frames.
2052 ALL-FRAMES `visible' means consider all windows on all visible
2054 ALL-FRAMES 0 means consider all windows on all visible and
2056 ALL-FRAMES a frame means consider all windows on that frame only.
2057 Anything else means consider all windows on WINDOW's frame and no
2060 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2061 `next-window' to iterate through the entire cycle of acceptable
2062 windows, eventually ending up back at the window you started with.
2063 `previous-window' traverses the same cycle, in the reverse order. */)
2064 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2066 return next_window (window
, minibuf
, all_frames
, 1);
2070 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2071 doc
: /* Return window preceding WINDOW in cyclic ordering of windows.
2072 WINDOW defaults to the selected window. The optional arguments
2073 MINIBUF and ALL-FRAMES specify the set of windows to consider.
2074 For the precise meaning of these arguments see `next-window'.
2076 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2077 use `previous-window' to iterate through the entire cycle of
2078 acceptable windows, eventually ending up back at the window you
2079 started with. `next-window' traverses the same cycle, in the
2081 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2083 return next_window (window
, minibuf
, all_frames
, 0);
2087 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
2088 doc
: /* Select another window in cyclic ordering of windows.
2089 COUNT specifies the number of windows to skip, starting with the
2090 selected window, before making the selection. If COUNT is
2091 positive, skip COUNT windows forwards. If COUNT is negative,
2092 skip -COUNT windows backwards. COUNT zero means do not skip any
2093 window, so select the selected window. In an interactive call,
2094 COUNT is the numeric prefix argument. Return nil.
2096 This function uses `next-window' for finding the window to select.
2097 The argument ALL-FRAMES has the same meaning as in `next-window',
2098 but the MINIBUF argument of `next-window' is always effectively
2100 (Lisp_Object count
, Lisp_Object all_frames
)
2105 CHECK_NUMBER (count
);
2106 window
= selected_window
;
2108 for (i
= XINT (count
); i
> 0; --i
)
2109 window
= Fnext_window (window
, Qnil
, all_frames
);
2111 window
= Fprevious_window (window
, Qnil
, all_frames
);
2113 Fselect_window (window
, Qnil
);
2118 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2119 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2120 FRAME nil or omitted means use the selected frame.
2121 WINDOW nil or omitted means use the selected window.
2122 MINIBUF t means include the minibuffer window, even if it isn't active.
2123 MINIBUF nil or omitted means include the minibuffer window only
2125 MINIBUF neither nil nor t means never include the minibuffer window. */)
2126 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2129 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2130 CHECK_WINDOW (window
);
2132 frame
= selected_frame
;
2134 if (!EQ (frame
, XWINDOW (window
)->frame
))
2135 error ("Window is on a different frame");
2137 return window_list_1 (window
, minibuf
, frame
);
2141 /* Return a list of windows in cyclic ordering. Arguments are like
2142 for `next-window'. */
2145 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2147 Lisp_Object tail
, list
, rest
;
2149 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2152 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2153 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2154 list
= Fcons (XCAR (tail
), list
);
2156 /* Rotate the list to start with WINDOW. */
2157 list
= Fnreverse (list
);
2158 rest
= Fmemq (window
, list
);
2159 if (!NILP (rest
) && !EQ (rest
, list
))
2161 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2163 XSETCDR (tail
, Qnil
);
2164 list
= nconc2 (rest
, list
);
2171 /* Look at all windows, performing an operation specified by TYPE
2173 If FRAMES is Qt, look at all frames;
2174 Qnil, look at just the selected frame;
2175 Qvisible, look at visible frames;
2176 a frame, just look at windows on that frame.
2177 If MINI is non-zero, perform the operation on minibuffer windows too. */
2182 GET_BUFFER_WINDOW
, /* Arg is buffer */
2183 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2184 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2185 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2187 UNSHOW_BUFFER
, /* Arg is buffer */
2188 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2193 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2195 Lisp_Object window
, windows
, best_window
, frame_arg
;
2197 struct gcpro gcpro1
;
2199 /* If we're only looping through windows on a particular frame,
2200 frame points to that frame. If we're looping through windows
2201 on all frames, frame is 0. */
2202 if (FRAMEP (frames
))
2203 f
= XFRAME (frames
);
2204 else if (NILP (frames
))
2205 f
= SELECTED_FRAME ();
2210 frame_arg
= Qlambda
;
2211 else if (EQ (frames
, make_number (0)))
2213 else if (EQ (frames
, Qvisible
))
2218 /* frame_arg is Qlambda to stick to one frame,
2219 Qvisible to consider all visible frames,
2222 /* Pick a window to start with. */
2226 window
= FRAME_SELECTED_WINDOW (f
);
2228 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2230 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2234 for (; CONSP (windows
); windows
= XCDR (windows
))
2238 window
= XCAR (windows
);
2239 w
= XWINDOW (window
);
2241 /* Note that we do not pay attention here to whether the frame
2242 is visible, since Fwindow_list skips non-visible frames if
2243 that is desired, under the control of frame_arg. */
2244 if (!MINI_WINDOW_P (w
)
2245 /* For UNSHOW_BUFFER, we must always consider all windows. */
2246 || type
== UNSHOW_BUFFER
2247 || (mini
&& minibuf_level
> 0))
2250 case GET_BUFFER_WINDOW
:
2251 if (EQ (w
->buffer
, obj
)
2252 /* Don't find any minibuffer window
2253 except the one that is currently in use. */
2254 && (MINI_WINDOW_P (w
)
2255 ? EQ (window
, minibuf_window
)
2258 if (NILP (best_window
))
2259 best_window
= window
;
2260 else if (EQ (window
, selected_window
))
2261 /* Prefer to return selected-window. */
2262 RETURN_UNGCPRO (window
);
2263 else if (EQ (Fwindow_frame (window
), selected_frame
))
2264 /* Prefer windows on the current frame. */
2265 best_window
= window
;
2269 case GET_LRU_WINDOW
:
2270 /* `obj' is an integer encoding a bitvector.
2271 `obj & 1' means consider only full-width windows.
2272 `obj & 2' means consider also dedicated windows. */
2273 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2274 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2275 /* Minibuffer windows are always ignored. */
2276 || MINI_WINDOW_P (w
))
2278 if (NILP (best_window
)
2279 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2280 > XFASTINT (w
->use_time
)))
2281 best_window
= window
;
2284 case DELETE_OTHER_WINDOWS
:
2285 if (!EQ (window
, obj
))
2286 Fdelete_window (window
);
2289 case DELETE_BUFFER_WINDOWS
:
2290 if (EQ (w
->buffer
, obj
))
2292 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2294 /* If this window is dedicated, and in a frame of its own,
2296 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2297 && !NILP (w
->dedicated
)
2298 && other_visible_frames (f
))
2300 /* Skip the other windows on this frame.
2301 There might be one, the minibuffer! */
2302 while (CONSP (XCDR (windows
))
2303 && EQ (XWINDOW (XCAR (windows
))->frame
,
2304 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2305 windows
= XCDR (windows
);
2307 /* Now we can safely delete the frame. */
2308 delete_frame (w
->frame
, Qnil
);
2310 else if (NILP (w
->parent
))
2312 /* If we're deleting the buffer displayed in the
2313 only window on the frame, find a new buffer to
2316 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2317 /* Reset dedicated state of window. */
2318 w
->dedicated
= Qnil
;
2319 Fset_window_buffer (window
, buffer
, Qnil
);
2320 if (EQ (window
, selected_window
))
2321 Fset_buffer (w
->buffer
);
2324 Fdelete_window (window
);
2328 case GET_LARGEST_WINDOW
:
2329 { /* nil `obj' means to ignore dedicated windows. */
2330 /* Ignore dedicated windows and minibuffers. */
2331 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2334 if (NILP (best_window
))
2335 best_window
= window
;
2338 struct window
*b
= XWINDOW (best_window
);
2339 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2340 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2341 best_window
= window
;
2347 if (EQ (w
->buffer
, obj
))
2350 struct frame
*f
= XFRAME (w
->frame
);
2352 /* Find another buffer to show in this window. */
2353 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2355 /* If this window is dedicated, and in a frame of its own,
2357 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2358 && !NILP (w
->dedicated
)
2359 && other_visible_frames (f
))
2361 /* Skip the other windows on this frame.
2362 There might be one, the minibuffer! */
2363 while (CONSP (XCDR (windows
))
2364 && EQ (XWINDOW (XCAR (windows
))->frame
,
2365 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2366 windows
= XCDR (windows
);
2368 /* Now we can safely delete the frame. */
2369 delete_frame (w
->frame
, Qnil
);
2371 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2374 XSETWINDOW (window
, w
);
2375 /* If this window is dedicated and not the only window
2376 in its frame, then kill it. */
2377 Fdelete_window (window
);
2381 /* Otherwise show a different buffer in the window. */
2382 w
->dedicated
= Qnil
;
2383 Fset_window_buffer (window
, buffer
, Qnil
);
2384 if (EQ (window
, selected_window
))
2385 Fset_buffer (w
->buffer
);
2390 case REDISPLAY_BUFFER_WINDOWS
:
2391 if (EQ (w
->buffer
, obj
))
2393 mark_window_display_accurate (window
, 0);
2394 w
->update_mode_line
= Qt
;
2395 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2396 ++update_mode_lines
;
2397 best_window
= window
;
2401 /* Check for a window that has a killed buffer. */
2402 case CHECK_ALL_WINDOWS
:
2403 if (! NILP (w
->buffer
)
2404 && NILP (XBUFFER (w
->buffer
)->name
))
2408 case WINDOW_LOOP_UNUSED
:
2417 /* Used for debugging. Abort if any window has a dead buffer. */
2420 check_all_windows (void)
2422 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2425 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2426 doc
: /* Return the window least recently selected or used for display.
2427 \(LRU means Least Recently Used.)
2429 Return a full-width window if possible.
2430 A minibuffer window is never a candidate.
2431 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2432 so if all windows are dedicated, the value is nil.
2433 If optional argument FRAME is `visible', search all visible frames.
2434 If FRAME is 0, search all visible and iconified frames.
2435 If FRAME is t, search all frames.
2436 If FRAME is nil, search only the selected frame.
2437 If FRAME is a frame, search only that frame. */)
2438 (Lisp_Object frame
, Lisp_Object dedicated
)
2440 register Lisp_Object w
;
2441 /* First try for a window that is full-width */
2442 w
= window_loop (GET_LRU_WINDOW
,
2443 NILP (dedicated
) ? make_number (1) : make_number (3),
2445 if (!NILP (w
) && !EQ (w
, selected_window
))
2447 /* If none of them, try the rest */
2448 return window_loop (GET_LRU_WINDOW
,
2449 NILP (dedicated
) ? make_number (0) : make_number (2),
2453 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2454 doc
: /* Return the largest window in area.
2455 A minibuffer window is never a candidate.
2456 A dedicated window is never a candidate unless DEDICATED is non-nil,
2457 so if all windows are dedicated, the value is nil.
2458 If optional argument FRAME is `visible', search all visible frames.
2459 If FRAME is 0, search all visible and iconified frames.
2460 If FRAME is t, search all frames.
2461 If FRAME is nil, search only the selected frame.
2462 If FRAME is a frame, search only that frame. */)
2463 (Lisp_Object frame
, Lisp_Object dedicated
)
2465 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2469 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2470 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2471 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to the
2473 If optional argument FRAME is `visible', search all visible frames.
2474 If optional argument FRAME is 0, search all visible and iconified frames.
2475 If FRAME is t, search all frames.
2476 If FRAME is nil, search only the selected frame.
2477 If FRAME is a frame, search only that frame. */)
2478 (Lisp_Object buffer_or_name
, Lisp_Object frame
)
2482 if (NILP (buffer_or_name
))
2483 buffer
= Fcurrent_buffer ();
2485 buffer
= Fget_buffer (buffer_or_name
);
2487 if (BUFFERP (buffer
))
2488 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2493 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2495 doc
: /* Make WINDOW (or the selected window) fill its frame.
2496 Only the frame WINDOW is on is affected.
2497 This function tries to reduce display jumps by keeping the text
2498 previously visible in WINDOW in the same place on the frame. Doing this
2499 depends on the value of (window-start WINDOW), so if calling this
2500 function in a program gives strange scrolling, make sure the
2501 window-start value is reasonable when this function is called. */)
2502 (Lisp_Object window
)
2509 window
= selected_window
;
2511 CHECK_LIVE_WINDOW (window
);
2512 w
= XWINDOW (window
);
2514 startpos
= marker_position (w
->start
);
2515 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2517 if (MINI_WINDOW_P (w
) && top
> 0)
2518 error ("Can't expand minibuffer to full frame");
2520 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2522 /* Try to minimize scrolling, by setting the window start to the point
2523 will cause the text at the old window start to be at the same place
2524 on the frame. But don't try to do this if the window start is
2525 outside the visible portion (as might happen when the display is
2526 not current, due to typeahead). */
2527 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2529 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2530 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2532 struct position pos
;
2533 struct buffer
*obuf
= current_buffer
;
2535 Fset_buffer (w
->buffer
);
2536 /* This computation used to temporarily move point, but that can
2537 have unwanted side effects due to text properties. */
2538 pos
= *vmotion (startpos
, -top
, w
);
2540 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2541 w
->window_end_valid
= Qnil
;
2542 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2543 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2545 /* We need to do this, so that the window-scroll-functions
2547 w
->optional_new_start
= Qt
;
2549 set_buffer_internal (obuf
);
2555 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2556 0, 2, "bDelete windows on (buffer): ",
2557 doc
: /* Delete all windows showing BUFFER-OR-NAME.
2558 BUFFER-OR-NAME may be a buffer or the name of an existing buffer and
2559 defaults to the current buffer.
2561 Optional second argument FRAME controls which frames are affected.
2562 If optional argument FRAME is `visible', search all visible frames.
2563 If FRAME is 0, search all visible and iconified frames.
2564 If FRAME is nil, search all frames.
2565 If FRAME is t, search only the selected frame.
2566 If FRAME is a frame, search only that frame.
2567 When a window showing BUFFER-OR-NAME is dedicated and the only window of
2568 its frame, that frame is deleted when there are other frames left. */)
2569 (Lisp_Object buffer_or_name
, Lisp_Object frame
)
2573 /* FRAME uses t and nil to mean the opposite of what window_loop
2577 else if (EQ (frame
, Qt
))
2580 if (NILP (buffer_or_name
))
2581 buffer
= Fcurrent_buffer ();
2584 buffer
= Fget_buffer (buffer_or_name
);
2585 CHECK_BUFFER (buffer
);
2588 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2593 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2594 Sreplace_buffer_in_windows
,
2595 0, 1, "bReplace buffer in windows: ",
2596 doc
: /* Replace BUFFER-OR-NAME with some other buffer in all windows showing it.
2597 BUFFER-OR-NAME may be a buffer or the name of an existing buffer and
2598 defaults to the current buffer.
2600 When a window showing BUFFER-OR-NAME is dedicated that window is
2601 deleted. If that window is the only window on its frame, that frame is
2602 deleted too when there are other frames left. If there are no other
2603 frames left, some other buffer is displayed in that window. */)
2604 (Lisp_Object buffer_or_name
)
2608 if (NILP (buffer_or_name
))
2609 buffer
= Fcurrent_buffer ();
2612 buffer
= Fget_buffer (buffer_or_name
);
2613 CHECK_BUFFER (buffer
);
2616 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2621 /* Replace BUFFER with some other buffer in all windows
2622 of all frames, even those on other keyboards. */
2625 replace_buffer_in_all_windows (Lisp_Object buffer
)
2627 Lisp_Object tail
, frame
;
2629 /* A single call to window_loop won't do the job
2630 because it only considers frames on the current keyboard.
2631 So loop manually over frames, and handle each one. */
2632 FOR_EACH_FRAME (tail
, frame
)
2633 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2636 /* Set the height of WINDOW and all its inferiors. */
2638 /* The smallest acceptable dimensions for a window. Anything smaller
2639 might crash Emacs. */
2641 #define MIN_SAFE_WINDOW_WIDTH (2)
2642 #define MIN_SAFE_WINDOW_HEIGHT (1)
2644 /* For wp non-zero the total number of columns of window w. Otherwise
2645 the total number of lines of w. */
2647 #define WINDOW_TOTAL_SIZE(w, wp) \
2648 (wp ? WINDOW_TOTAL_COLS (w) : WINDOW_TOTAL_LINES (w))
2650 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2651 minimum allowable size. */
2654 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2656 /* For height, we have to see:
2657 how many windows the frame has at minimum (one or two),
2658 and whether it has a menu bar or other special stuff at the top. */
2660 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2661 ? MIN_SAFE_WINDOW_HEIGHT
2662 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2664 if (FRAME_TOP_MARGIN (frame
) > 0)
2665 min_height
+= FRAME_TOP_MARGIN (frame
);
2667 if (*rows
< min_height
)
2669 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2670 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2673 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2674 check if W's width can be changed, otherwise check W's height.
2675 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2676 siblings, too. If none of the siblings is resizable, WINDOW isn't
2680 window_fixed_size_p (struct window
*w
, int width_p
, int check_siblings_p
)
2685 if (!NILP (w
->hchild
))
2687 c
= XWINDOW (w
->hchild
);
2691 /* A horizontal combination is fixed-width if all of if its
2693 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2694 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2695 fixed_p
= c
== NULL
;
2699 /* A horizontal combination is fixed-height if one of if its
2701 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2702 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2703 fixed_p
= c
!= NULL
;
2706 else if (!NILP (w
->vchild
))
2708 c
= XWINDOW (w
->vchild
);
2712 /* A vertical combination is fixed-width if one of if its
2714 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2715 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2716 fixed_p
= c
!= NULL
;
2720 /* A vertical combination is fixed-height if all of if its
2722 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2723 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2724 fixed_p
= c
== NULL
;
2727 else if (BUFFERP (w
->buffer
))
2729 struct buffer
*old
= current_buffer
;
2732 current_buffer
= XBUFFER (w
->buffer
);
2733 val
= find_symbol_value (Qwindow_size_fixed
);
2734 current_buffer
= old
;
2737 if (!EQ (val
, Qunbound
))
2739 fixed_p
= !NILP (val
);
2742 && ((EQ (val
, Qheight
) && width_p
)
2743 || (EQ (val
, Qwidth
) && !width_p
)))
2747 /* Can't tell if this one is resizable without looking at
2748 siblings. If all siblings are fixed-size this one is too. */
2749 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2753 for (child
= w
->prev
; WINDOWP (child
); child
= XWINDOW (child
)->prev
)
2754 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2758 for (child
= w
->next
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
2759 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2772 /* Return minimum size of leaf window W. WIDTH_P non-zero means return
2773 the minimum width of W, WIDTH_P zero means return the minimum height
2774 of W. SAFE_P non-zero means ignore window-min-height|width but just
2775 return values that won't crash Emacs and don't hide components like
2776 fringes, scrollbars, or modelines. If WIDTH_P is zero and W is the
2777 minibuffer window, always return 1. */
2780 window_min_size_2 (struct window
*w
, int width_p
, int safe_p
)
2782 /* We should consider buffer-local values of window_min_height and
2783 window_min_width here. */
2786 int safe_size
= (MIN_SAFE_WINDOW_WIDTH
2787 + WINDOW_FRINGE_COLS (w
)
2788 + WINDOW_SCROLL_BAR_COLS (w
));
2790 return safe_p
? safe_size
: max (window_min_width
, safe_size
);
2792 else if (MINI_WINDOW_P (w
))
2796 int safe_size
= (MIN_SAFE_WINDOW_HEIGHT
2797 + ((BUFFERP (w
->buffer
)
2798 && !NILP (XBUFFER (w
->buffer
)->mode_line_format
))
2801 return safe_p
? safe_size
: max (window_min_height
, safe_size
);
2805 /* Return minimum size of window W, not taking fixed-width windows into
2806 account. WIDTH_P non-zero means return the minimum width, otherwise
2807 return the minimum height. SAFE_P non-zero means ignore
2808 window-min-height|width but just return values that won't crash Emacs
2809 and don't hide components like fringes, scrollbars, or modelines. If
2810 W is a combination window, compute the minimum size from the minimum
2811 sizes of W's children. */
2814 window_min_size_1 (struct window
*w
, int width_p
, int safe_p
)
2819 if (!NILP (w
->hchild
))
2821 /* W is a horizontal combination. */
2822 c
= XWINDOW (w
->hchild
);
2827 /* The minimum width of a horizontal combination is the sum of
2828 the minimum widths of its children. */
2831 size
+= window_min_size_1 (c
, 1, safe_p
);
2832 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2837 /* The minimum height of a horizontal combination is the
2838 maximum of the minimum heights of its children. */
2841 size
= max (window_min_size_1 (c
, 0, safe_p
), size
);
2842 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2846 else if (!NILP (w
->vchild
))
2848 /* W is a vertical combination. */
2849 c
= XWINDOW (w
->vchild
);
2854 /* The minimum width of a vertical combination is the maximum
2855 of the minimum widths of its children. */
2858 size
= max (window_min_size_1 (c
, 1, safe_p
), size
);
2859 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2864 /* The minimum height of a vertical combination is the sum of
2865 the minimum height of its children. */
2868 size
+= window_min_size_1 (c
, 0, safe_p
);
2869 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2874 /* W is a leaf window. */
2875 size
= window_min_size_2 (w
, width_p
, safe_p
);
2880 /* Return the minimum size of window W, taking fixed-size windows into
2881 account. WIDTH_P non-zero means return the minimum width, otherwise
2882 return the minimum height. SAFE_P non-zero means ignore
2883 window-min-height|width but just return values that won't crash Emacs
2884 and don't hide components like fringes, scrollbars, or modelines.
2885 IGNORE_FIXED_P non-zero means ignore if W is fixed-size. Set *FIXED
2886 to 1 if W is fixed-size unless FIXED is null. */
2889 window_min_size (struct window
*w
, int width_p
, int safe_p
, int ignore_fixed_p
, int *fixed
)
2896 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2902 size
= WINDOW_TOTAL_SIZE (w
, width_p
);
2904 size
= window_min_size_1 (w
, width_p
, safe_p
);
2910 /* Adjust the margins of window W if text area is too small.
2911 Return 1 if window width is ok after adjustment; 0 if window
2912 is still too narrow. */
2915 adjust_window_margins (struct window
*w
)
2917 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2918 - WINDOW_FRINGE_COLS (w
)
2919 - WINDOW_SCROLL_BAR_COLS (w
));
2920 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2921 + WINDOW_RIGHT_MARGIN_COLS (w
));
2923 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2926 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2929 /* Window's text area is too narrow, but reducing the window
2930 margins will fix that. */
2931 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2932 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2934 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2935 w
->left_margin_cols
= w
->right_margin_cols
2936 = make_number (margin_cols
/2);
2938 w
->right_margin_cols
= make_number (margin_cols
);
2941 w
->left_margin_cols
= make_number (margin_cols
);
2945 /* Calculate new sizes for windows in the list FORWARD when their
2946 compound size goes from TOTAL to SIZE. TOTAL must be greater than
2947 SIZE. The number of windows in FORWARD is NCHILDREN, and the number
2948 that can shrink is SHRINKABLE. Fixed-size windows may be shrunk if
2949 and only if RESIZE_FIXED_P is non-zero. WIDTH_P non-zero means
2950 shrink columns, otherwise shrink lines.
2952 SAFE_P zero means windows may be sized down to window-min-height
2953 lines (window-min-window columns for WIDTH_P non-zero). SAFE_P
2954 non-zero means windows may be sized down to their minimum safe sizes
2955 taking into account the space needed to display modelines, fringes,
2958 This function returns an allocated array of new sizes that the caller
2959 must free. A size -1 means the window is fixed and RESIZE_FIXED_P is
2960 zero. A size zero means the window shall be deleted. Array index 0
2961 refers to the first window in FORWARD, 1 to the second, and so on.
2963 This function resizes windows proportionally to their size. It also
2964 tries to preserve smaller windows by resizing larger windows before
2965 resizing any window to zero. If resize_proportionally is non-nil for
2966 a specific window, it will attempt to strictly resize that window
2967 proportionally, even at the expense of deleting smaller windows. */
2969 shrink_windows (int total
, int size
, int nchildren
, int shrinkable
,
2970 int resize_fixed_p
, Lisp_Object forward
, int width_p
, int safe_p
)
2972 int available_resize
= 0;
2973 int *new_sizes
, *min_sizes
;
2976 int smallest
= total
;
2977 int total_removed
= 0;
2978 int total_shrink
= total
- size
;
2981 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2982 min_sizes
= xmalloc (sizeof (*min_sizes
) * nchildren
);
2984 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2988 c
= XWINDOW (child
);
2989 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
2991 if (!resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2995 new_sizes
[i
] = child_size
;
2996 min_sizes
[i
] = window_min_size_1 (c
, width_p
, safe_p
);
2997 if (child_size
> min_sizes
[i
]
2998 && NILP (c
->resize_proportionally
))
2999 available_resize
+= child_size
- min_sizes
[i
];
3002 /* We might need to shrink some windows to zero. Find the smallest
3003 windows and set them to 0 until we can fulfil the new size. */
3005 while (shrinkable
> 1 && size
+ available_resize
< total
)
3007 for (i
= 0; i
< nchildren
; ++i
)
3008 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
3009 smallest
= new_sizes
[i
];
3011 for (i
= 0; i
< nchildren
; ++i
)
3012 if (new_sizes
[i
] == smallest
)
3014 /* Resize this window down to zero. */
3016 if (smallest
> min_sizes
[i
])
3017 available_resize
-= smallest
- min_sizes
[i
];
3018 available_resize
+= smallest
;
3020 total_removed
+= smallest
;
3022 /* We don't know what the smallest is now. */
3025 /* Out of for, just remove one window at the time and
3026 check again if we have enough space. */
3031 /* Now, calculate the new sizes. Try to shrink each window
3032 proportional to its size. */
3033 for (i
= 0; i
< nchildren
; ++i
)
3035 if (new_sizes
[i
] > min_sizes
[i
])
3037 int to_shrink
= total_shrink
* new_sizes
[i
] / total
;
3039 if (new_sizes
[i
] - to_shrink
< min_sizes
[i
])
3040 to_shrink
= new_sizes
[i
] - min_sizes
[i
];
3041 new_sizes
[i
] -= to_shrink
;
3042 total_removed
+= to_shrink
;
3046 /* Any reminder due to rounding, we just subtract from windows
3047 that are left and still can be shrunk. */
3048 while (total_shrink
> total_removed
)
3050 int nonzero_sizes
= 0;
3051 int nonzero_idx
= -1;
3053 for (i
= 0; i
< nchildren
; ++i
)
3054 if (new_sizes
[i
] > 0)
3060 for (i
= 0; i
< nchildren
; ++i
)
3061 if (new_sizes
[i
] > min_sizes
[i
])
3066 /* Out of for, just shrink one window at the time and
3067 check again if we have enough space. */
3071 /* Special case, only one window left. */
3072 if (nonzero_sizes
== 1)
3076 /* Any surplus due to rounding, we add to windows that are left. */
3077 while (total_shrink
< total_removed
)
3079 for (i
= 0; i
< nchildren
; ++i
)
3081 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
3095 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
3096 WINDOW's width. Resize WINDOW's children, if any, so that they keep
3097 their proportionate size relative to WINDOW.
3099 If FIRST_ONLY is 1, change only the first of WINDOW's children when
3100 they are in series. If LAST_ONLY is 1, change only the last of
3101 WINDOW's children when they are in series.
3103 Propagate WINDOW's top or left edge position to children. Delete
3104 windows that become too small unless NODELETE_P is 1. When
3105 NODELETE_P equals 2 do not honor settings for window-min-height and
3106 window-min-width when resizing windows but use safe defaults instead.
3107 This should give better behavior when resizing frames. */
3110 size_window (Lisp_Object window
, int size
, int width_p
, int nodelete_p
, int first_only
, int last_only
)
3112 struct window
*w
= XWINDOW (window
);
3114 Lisp_Object child
, *forward
, *sideward
;
3115 int old_size
= WINDOW_TOTAL_SIZE (w
, width_p
);
3117 size
= max (0, size
);
3119 /* Delete WINDOW if it's too small. */
3120 if (nodelete_p
!= 1 && !NILP (w
->parent
)
3121 && size
< window_min_size_1 (w
, width_p
, nodelete_p
== 2))
3123 delete_window (window
);
3127 /* Set redisplay hints. */
3128 w
->last_modified
= make_number (0);
3129 w
->last_overlay_modified
= make_number (0);
3130 windows_or_buffers_changed
++;
3131 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3135 sideward
= &w
->vchild
;
3136 forward
= &w
->hchild
;
3137 w
->total_cols
= make_number (size
);
3138 adjust_window_margins (w
);
3142 sideward
= &w
->hchild
;
3143 forward
= &w
->vchild
;
3144 w
->total_lines
= make_number (size
);
3145 w
->orig_total_lines
= Qnil
;
3148 if (!NILP (*sideward
))
3150 /* We have a chain of parallel siblings whose size should all change. */
3151 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3153 c
= XWINDOW (child
);
3155 c
->left_col
= w
->left_col
;
3157 c
->top_line
= w
->top_line
;
3158 size_window (child
, size
, width_p
, nodelete_p
,
3159 first_only
, last_only
);
3162 else if (!NILP (*forward
) && last_only
)
3164 /* Change the last in a series of siblings. */
3165 Lisp_Object last_child
;
3168 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3170 c
= XWINDOW (child
);
3174 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3175 size_window (last_child
, size
- old_size
+ child_size
,
3176 width_p
, nodelete_p
, first_only
, last_only
);
3178 else if (!NILP (*forward
) && first_only
)
3180 /* Change the first in a series of siblings. */
3184 c
= XWINDOW (child
);
3187 c
->left_col
= w
->left_col
;
3189 c
->top_line
= w
->top_line
;
3191 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3192 size_window (child
, size
- old_size
+ child_size
,
3193 width_p
, nodelete_p
, first_only
, last_only
);
3195 else if (!NILP (*forward
))
3197 int fixed_size
, each
, extra
, n
;
3198 int resize_fixed_p
, nfixed
;
3199 int last_pos
, first_pos
, nchildren
, total
;
3200 int *new_sizes
= NULL
;
3202 /* Determine the fixed-size portion of this window, and the
3203 number of child windows. */
3204 fixed_size
= nchildren
= nfixed
= total
= 0;
3205 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3209 c
= XWINDOW (child
);
3210 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3211 total
+= child_size
;
3213 if (window_fixed_size_p (c
, width_p
, 0))
3215 fixed_size
+= child_size
;
3220 /* If the new size is smaller than fixed_size, or if there
3221 aren't any resizable windows, allow resizing fixed-size
3223 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3225 /* Compute how many lines/columns to add/remove to each child. The
3226 value of extra takes care of rounding errors. */
3227 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3228 if (size
< total
&& n
> 1)
3229 new_sizes
= shrink_windows (total
, size
, nchildren
, n
,
3230 resize_fixed_p
, *forward
, width_p
,
3234 each
= (size
- total
) / n
;
3235 extra
= (size
- total
) - n
* each
;
3238 /* Compute new children heights and edge positions. */
3239 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3240 last_pos
= first_pos
;
3241 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3243 int new_size
, old_size
;
3245 c
= XWINDOW (child
);
3246 old_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3247 new_size
= old_size
;
3249 /* The top or left edge position of this child equals the
3250 bottom or right edge of its predecessor. */
3252 c
->left_col
= make_number (last_pos
);
3254 c
->top_line
= make_number (last_pos
);
3256 /* If this child can be resized, do it. */
3257 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3259 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3263 /* Set new size. Note that size_window also propagates
3264 edge positions to children, so it's not a no-op if we
3265 didn't change the child's size. */
3266 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3268 /* Remember the bottom/right edge position of this child; it
3269 will be used to set the top/left edge of the next child. */
3270 last_pos
+= new_size
;
3275 /* We should have covered the parent exactly with child windows. */
3276 xassert (size
== last_pos
- first_pos
);
3278 /* Now delete any children that became too small. */
3279 if (nodelete_p
!= 1)
3280 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3284 c
= XWINDOW (child
);
3285 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3286 size_window (child
, child_size
, width_p
, nodelete_p
,
3287 first_only
, last_only
);
3292 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3293 WINDOW's children. NODELETE zero means windows that have become
3294 smaller than window-min-height in the process may be deleted.
3295 NODELETE 1 means never delete windows that become too small in the
3296 process. (The caller should check later and do so if appropriate.)
3297 NODELETE 2 means delete only windows that have become too small to be
3298 displayed correctly. */
3301 set_window_height (Lisp_Object window
, int height
, int nodelete
)
3303 size_window (window
, height
, 0, nodelete
, 0, 0);
3306 /* Set WINDOW's width to WIDTH, and recursively change the width of
3307 WINDOW's children. NODELETE zero means windows that have become
3308 smaller than window-min-width in the process may be deleted.
3309 NODELETE 1 means never delete windows that become too small in the
3310 process. (The caller should check later and do so if appropriate.)
3311 NODELETE 2 means delete only windows that have become too small to be
3312 displayed correctly. */
3315 set_window_width (Lisp_Object window
, int width
, int nodelete
)
3317 size_window (window
, width
, 1, nodelete
, 0, 0);
3320 /* Change window heights in windows rooted in WINDOW by N lines. */
3323 change_window_heights (Lisp_Object window
, int n
)
3325 struct window
*w
= XWINDOW (window
);
3327 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3328 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3330 if (INTEGERP (w
->orig_top_line
))
3331 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3332 if (INTEGERP (w
->orig_total_lines
))
3333 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3335 /* Handle just the top child in a vertical split. */
3336 if (!NILP (w
->vchild
))
3337 change_window_heights (w
->vchild
, n
);
3339 /* Adjust all children in a horizontal split. */
3340 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3342 w
= XWINDOW (window
);
3343 change_window_heights (window
, n
);
3348 int window_select_count
;
3350 EXFUN (Fset_window_fringes
, 4);
3351 EXFUN (Fset_window_scroll_bars
, 4);
3354 run_funs (Lisp_Object funs
)
3356 for (; CONSP (funs
); funs
= XCDR (funs
))
3357 if (!EQ (XCAR (funs
), Qt
))
3358 call0 (XCAR (funs
));
3361 static Lisp_Object
select_window_norecord (Lisp_Object window
);
3362 static Lisp_Object
select_frame_norecord (Lisp_Object frame
);
3365 run_window_configuration_change_hook (struct frame
*f
)
3367 int count
= SPECPDL_INDEX ();
3368 Lisp_Object frame
, global_wcch
3369 = Fdefault_value (Qwindow_configuration_change_hook
);
3370 XSETFRAME (frame
, f
);
3372 if (NILP (Vrun_hooks
))
3375 if (SELECTED_FRAME () != f
)
3377 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3378 Fselect_frame (frame
, Qt
);
3381 /* Use the right buffer. Matters when running the local hooks. */
3382 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3384 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3385 Fset_buffer (Fwindow_buffer (Qnil
));
3388 /* Look for buffer-local values. */
3390 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3391 for (; CONSP (windows
); windows
= XCDR (windows
))
3393 Lisp_Object window
= XCAR (windows
);
3394 Lisp_Object buffer
= Fwindow_buffer (window
);
3395 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3398 int count
= SPECPDL_INDEX ();
3399 record_unwind_protect (select_window_norecord
, Fselected_window ());
3400 select_window_norecord (window
);
3401 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3403 unbind_to (count
, Qnil
);
3408 run_funs (global_wcch
);
3409 unbind_to (count
, Qnil
);
3412 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3413 means it's allowed to run hooks. See make_frame for a case where
3414 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3415 margins, fringes, and scroll-bar settings of the window are not
3416 reset from the buffer's local settings. */
3419 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3421 struct window
*w
= XWINDOW (window
);
3422 struct buffer
*b
= XBUFFER (buffer
);
3423 int count
= SPECPDL_INDEX ();
3424 int samebuf
= EQ (buffer
, w
->buffer
);
3428 if (EQ (window
, selected_window
))
3429 b
->last_selected_window
= window
;
3431 /* Let redisplay errors through. */
3432 b
->display_error_modiff
= 0;
3434 /* Update time stamps of buffer display. */
3435 if (INTEGERP (b
->display_count
))
3436 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3437 b
->display_time
= Fcurrent_time ();
3439 XSETFASTINT (w
->window_end_pos
, 0);
3440 XSETFASTINT (w
->window_end_vpos
, 0);
3441 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3442 w
->window_end_valid
= Qnil
;
3443 if (!(keep_margins_p
&& samebuf
))
3444 { /* If we're not actually changing the buffer, don't reset hscroll and
3445 vscroll. This case happens for example when called from
3446 change_frame_size_1, where we use a dummy call to
3447 Fset_window_buffer on the frame's selected window (and no other)
3448 just in order to run window-configuration-change-hook.
3449 Resetting hscroll and vscroll here is problematic for things like
3450 image-mode and doc-view-mode since it resets the image's position
3451 whenever we resize the frame. */
3452 w
->hscroll
= w
->min_hscroll
= make_number (0);
3454 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3455 set_marker_restricted (w
->start
,
3456 make_number (b
->last_window_start
),
3458 w
->start_at_line_beg
= Qnil
;
3459 w
->force_start
= Qnil
;
3460 XSETFASTINT (w
->last_modified
, 0);
3461 XSETFASTINT (w
->last_overlay_modified
, 0);
3463 /* Maybe we could move this into the `if' but it's not obviously safe and
3464 I doubt it's worth the trouble. */
3465 windows_or_buffers_changed
++;
3467 /* We must select BUFFER for running the window-scroll-functions. */
3468 /* We can't check ! NILP (Vwindow_scroll_functions) here
3469 because that might itself be a local variable. */
3470 if (window_initialized
)
3472 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3473 Fset_buffer (buffer
);
3476 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3478 if (!keep_margins_p
)
3480 /* Set left and right marginal area width etc. from buffer. */
3482 /* This may call adjust_window_margins three times, so
3483 temporarily disable window margins. */
3484 Lisp_Object save_left
= w
->left_margin_cols
;
3485 Lisp_Object save_right
= w
->right_margin_cols
;
3487 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3489 Fset_window_fringes (window
,
3490 b
->left_fringe_width
, b
->right_fringe_width
,
3491 b
->fringes_outside_margins
);
3493 Fset_window_scroll_bars (window
,
3494 b
->scroll_bar_width
,
3495 b
->vertical_scroll_bar_type
, Qnil
);
3497 w
->left_margin_cols
= save_left
;
3498 w
->right_margin_cols
= save_right
;
3500 Fset_window_margins (window
,
3501 b
->left_margin_cols
, b
->right_margin_cols
);
3506 if (! NILP (Vwindow_scroll_functions
))
3507 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3508 Fmarker_position (w
->start
));
3509 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3512 unbind_to (count
, Qnil
);
3516 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3517 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3518 WINDOW defaults to the selected window. BUFFER-OR-NAME must be a buffer
3519 or the name of an existing buffer. Optional third argument KEEP-MARGINS
3520 non-nil means that WINDOW's current display margins, fringe widths, and
3521 scroll bar settings are preserved; the default is to reset these from
3522 the local settings for BUFFER-OR-NAME or the frame defaults. Return nil.
3524 This function throws an error when WINDOW is strongly dedicated to its
3525 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3526 already display BUFFER-OR-NAME.
3528 This function runs `window-scroll-functions' before running
3529 `window-configuration-change-hook'. */)
3530 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3532 register Lisp_Object tem
, buffer
;
3533 register struct window
*w
= decode_window (window
);
3535 XSETWINDOW (window
, w
);
3536 buffer
= Fget_buffer (buffer_or_name
);
3537 CHECK_BUFFER (buffer
);
3538 if (NILP (XBUFFER (buffer
)->name
))
3539 error ("Attempt to display deleted buffer");
3543 error ("Window is deleted");
3544 else if (!EQ (tem
, Qt
))
3545 /* w->buffer is t when the window is first being set up. */
3547 if (!EQ (tem
, buffer
))
3548 if (EQ (w
->dedicated
, Qt
))
3549 error ("Window is dedicated to `%s'", SDATA (XBUFFER (tem
)->name
));
3551 w
->dedicated
= Qnil
;
3556 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3560 /* Note that selected_window can be nil when this is called from
3561 Fset_window_configuration. */
3563 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3564 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3565 If WINDOW is not already selected, make WINDOW's buffer current
3566 and make WINDOW the frame's selected window. Return WINDOW.
3567 Optional second arg NORECORD non-nil means do not put this buffer
3568 at the front of the list of recently selected ones and do not
3569 make this window the most recently selected one.
3571 Note that the main editor command loop selects the buffer of the
3572 selected window before each command. */)
3573 (register Lisp_Object window
, Lisp_Object norecord
)
3575 register struct window
*w
;
3576 register struct window
*ow
;
3579 CHECK_LIVE_WINDOW (window
);
3581 w
= XWINDOW (window
);
3582 w
->frozen_window_start_p
= 0;
3584 if (NILP (norecord
))
3586 ++window_select_count
;
3587 XSETFASTINT (w
->use_time
, window_select_count
);
3588 record_buffer (w
->buffer
);
3591 if (EQ (window
, selected_window
))
3594 sf
= SELECTED_FRAME ();
3595 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3597 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3598 /* Use this rather than Fhandle_switch_frame
3599 so that FRAME_FOCUS_FRAME is moved appropriately as we
3600 move around in the state where a minibuffer in a separate
3602 Fselect_frame (WINDOW_FRAME (w
), norecord
);
3603 /* Fselect_frame called us back so we've done all the work already. */
3604 eassert (EQ (window
, selected_window
));
3608 sf
->selected_window
= window
;
3610 /* Store the current buffer's actual point into the
3611 old selected window. It belongs to that window,
3612 and when the window is not selected, must be in the window. */
3613 if (!NILP (selected_window
))
3615 ow
= XWINDOW (selected_window
);
3616 if (! NILP (ow
->buffer
))
3617 set_marker_both (ow
->pointm
, ow
->buffer
,
3618 BUF_PT (XBUFFER (ow
->buffer
)),
3619 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3622 selected_window
= window
;
3624 Fset_buffer (w
->buffer
);
3626 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3628 /* Go to the point recorded in the window.
3629 This is important when the buffer is in more
3630 than one window. It also matters when
3631 redisplay_window has altered point after scrolling,
3632 because it makes the change only in the window. */
3634 register int new_point
= marker_position (w
->pointm
);
3635 if (new_point
< BEGV
)
3637 else if (new_point
> ZV
)
3643 windows_or_buffers_changed
++;
3648 select_window_norecord (Lisp_Object window
)
3650 return WINDOW_LIVE_P (window
)
3651 ? Fselect_window (window
, Qt
) : selected_window
;
3655 select_frame_norecord (Lisp_Object frame
)
3657 return FRAME_LIVE_P (XFRAME (frame
))
3658 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3662 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3664 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3667 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3669 doc
: /* Force all windows to be updated on next redisplay.
3670 If optional arg OBJECT is a window, force redisplay of that window only.
3671 If OBJECT is a buffer or buffer name, force redisplay of all windows
3672 displaying that buffer. */)
3673 (Lisp_Object object
)
3677 windows_or_buffers_changed
++;
3678 update_mode_lines
++;
3682 if (WINDOWP (object
))
3684 struct window
*w
= XWINDOW (object
);
3685 mark_window_display_accurate (object
, 0);
3686 w
->update_mode_line
= Qt
;
3687 if (BUFFERP (w
->buffer
))
3688 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3689 ++update_mode_lines
;
3693 if (STRINGP (object
))
3694 object
= Fget_buffer (object
);
3695 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3697 /* Walk all windows looking for buffer, and force update
3698 of each of those windows. */
3700 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3701 return NILP (object
) ? Qnil
: Qt
;
3704 /* If nothing suitable was found, just return.
3705 We could signal an error, but this feature will typically be used
3706 asynchronously in timers or process sentinels, so we don't. */
3712 temp_output_buffer_show (register Lisp_Object buf
)
3714 register struct buffer
*old
= current_buffer
;
3715 register Lisp_Object window
;
3716 register struct window
*w
;
3718 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3721 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3725 #if 0 /* rms: there should be no reason for this. */
3726 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3728 set_buffer_internal (old
);
3730 if (!NILP (Vtemp_buffer_show_function
))
3731 call1 (Vtemp_buffer_show_function
, buf
);
3734 window
= display_buffer (buf
, Qnil
, Qnil
);
3736 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3737 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3738 Vminibuf_scroll_window
= window
;
3739 w
= XWINDOW (window
);
3740 XSETFASTINT (w
->hscroll
, 0);
3741 XSETFASTINT (w
->min_hscroll
, 0);
3742 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3743 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3745 /* Run temp-buffer-show-hook, with the chosen window selected
3746 and its buffer current. */
3748 if (!NILP (Vrun_hooks
)
3749 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3750 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3752 int count
= SPECPDL_INDEX ();
3753 Lisp_Object prev_window
, prev_buffer
;
3754 prev_window
= selected_window
;
3755 XSETBUFFER (prev_buffer
, old
);
3757 /* Select the window that was chosen, for running the hook.
3758 Note: Both Fselect_window and select_window_norecord may
3759 set-buffer to the buffer displayed in the window,
3760 so we need to save the current buffer. --stef */
3761 record_unwind_protect (Fset_buffer
, prev_buffer
);
3762 record_unwind_protect (select_window_norecord
, prev_window
);
3763 Fselect_window (window
, Qt
);
3764 Fset_buffer (w
->buffer
);
3765 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3766 unbind_to (count
, Qnil
);
3772 make_dummy_parent (Lisp_Object window
)
3775 register struct window
*o
, *p
;
3778 o
= XWINDOW (window
);
3779 p
= allocate_window ();
3780 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3781 ((struct Lisp_Vector
*) p
)->contents
[i
]
3782 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3783 XSETWINDOW (new, p
);
3786 XSETFASTINT (p
->sequence_number
, sequence_number
);
3788 /* Put new into window structure in place of window */
3789 replace_window (window
, new);
3802 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3803 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3804 WINDOW defaults to selected one and SIZE to half its size.
3805 If optional third arg HORIZONTAL is non-nil, split side by side and put
3806 SIZE columns in the first of the pair. In that case, SIZE includes that
3807 window's scroll bar, or the divider column to its right.
3808 Interactively, all arguments are nil.
3809 Returns the newly created window (which is the lower or rightmost one).
3810 The upper or leftmost window is the original one, and remains selected
3811 if it was selected before.
3813 See Info node `(elisp)Splitting Windows' for more details and examples. */)
3814 (Lisp_Object window
, Lisp_Object size
, Lisp_Object horizontal
)
3816 register Lisp_Object
new;
3817 register struct window
*o
, *p
;
3819 register int size_int
;
3822 window
= selected_window
;
3824 CHECK_LIVE_WINDOW (window
);
3826 o
= XWINDOW (window
);
3827 fo
= XFRAME (WINDOW_FRAME (o
));
3831 if (!NILP (horizontal
))
3832 /* Calculate the size of the left-hand window, by dividing
3833 the usable space in columns by two.
3834 We round up, since the left-hand window may include
3835 a dividing line, while the right-hand may not. */
3836 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3838 size_int
= XFASTINT (o
->total_lines
) >> 1;
3842 CHECK_NUMBER (size
);
3843 size_int
= XINT (size
);
3846 if (MINI_WINDOW_P (o
))
3847 error ("Attempt to split minibuffer window");
3848 else if (window_fixed_size_p (o
, !NILP (horizontal
), 0))
3849 error ("Attempt to split fixed-size window");
3851 if (NILP (horizontal
))
3853 int window_safe_height
= window_min_size_2 (o
, 0, 0);
3855 if (size_int
< window_safe_height
)
3856 error ("Window height %d too small (after splitting)", size_int
);
3857 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
3858 error ("Window height %d too small (after splitting)",
3859 XFASTINT (o
->total_lines
) - size_int
);
3860 if (NILP (o
->parent
)
3861 || NILP (XWINDOW (o
->parent
)->vchild
))
3863 make_dummy_parent (window
);
3865 XWINDOW (new)->vchild
= window
;
3870 int window_safe_width
= window_min_size_2 (o
, 1, 0);
3872 if (size_int
< window_safe_width
)
3873 error ("Window width %d too small (after splitting)", size_int
);
3874 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
3875 error ("Window width %d too small (after splitting)",
3876 XFASTINT (o
->total_cols
) - size_int
);
3877 if (NILP (o
->parent
)
3878 || NILP (XWINDOW (o
->parent
)->hchild
))
3880 make_dummy_parent (window
);
3882 XWINDOW (new)->hchild
= window
;
3886 /* Now we know that window's parent is a vertical combination
3887 if we are dividing vertically, or a horizontal combination
3888 if we are making side-by-side windows */
3890 windows_or_buffers_changed
++;
3891 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3892 new = make_window ();
3895 p
->frame
= o
->frame
;
3897 if (!NILP (p
->next
))
3898 XWINDOW (p
->next
)->prev
= new;
3901 p
->parent
= o
->parent
;
3903 p
->window_end_valid
= Qnil
;
3904 memset (&p
->last_cursor
, 0, sizeof p
->last_cursor
);
3906 /* Duplicate special geometry settings. */
3908 p
->left_margin_cols
= o
->left_margin_cols
;
3909 p
->right_margin_cols
= o
->right_margin_cols
;
3910 p
->left_fringe_width
= o
->left_fringe_width
;
3911 p
->right_fringe_width
= o
->right_fringe_width
;
3912 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3913 p
->scroll_bar_width
= o
->scroll_bar_width
;
3914 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3916 /* Apportion the available frame space among the two new windows */
3918 if (!NILP (horizontal
))
3920 p
->total_lines
= o
->total_lines
;
3921 p
->top_line
= o
->top_line
;
3922 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3923 XSETFASTINT (o
->total_cols
, size_int
);
3924 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3925 adjust_window_margins (p
);
3926 adjust_window_margins (o
);
3930 p
->left_col
= o
->left_col
;
3931 p
->total_cols
= o
->total_cols
;
3932 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3933 XSETFASTINT (o
->total_lines
, size_int
);
3934 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3937 /* Adjust glyph matrices. */
3940 Fset_window_buffer (new, o
->buffer
, Qt
);
3944 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3945 doc
: /* Make selected window SIZE lines taller.
3946 Interactively, if no argument is given, make the selected window one
3947 line taller. If optional argument HORIZONTAL is non-nil, make selected
3948 window wider by SIZE columns. If SIZE is negative, shrink the window by
3949 -SIZE lines or columns. Return nil.
3951 This function can delete windows if they get too small. The size of
3952 fixed size windows is not altered by this function. */)
3953 (Lisp_Object size
, Lisp_Object horizontal
)
3955 CHECK_NUMBER (size
);
3956 enlarge_window (selected_window
, XINT (size
), !NILP (horizontal
));
3958 run_window_configuration_change_hook (SELECTED_FRAME ());
3963 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3964 doc
: /* Make selected window SIZE lines smaller.
3965 Interactively, if no argument is given, make the selected window one
3966 line smaller. If optional argument HORIZONTAL is non-nil, make the
3967 window narrower by SIZE columns. If SIZE is negative, enlarge selected
3968 window by -SIZE lines or columns. Return nil.
3970 This function can delete windows if they get too small. The size of
3971 fixed size windows is not altered by this function. */)
3972 (Lisp_Object size
, Lisp_Object horizontal
)
3974 CHECK_NUMBER (size
);
3975 enlarge_window (selected_window
, -XINT (size
), !NILP (horizontal
));
3977 run_window_configuration_change_hook (SELECTED_FRAME ());
3983 window_height (Lisp_Object window
)
3985 register struct window
*p
= XWINDOW (window
);
3986 return WINDOW_TOTAL_LINES (p
);
3990 window_width (Lisp_Object window
)
3992 register struct window
*p
= XWINDOW (window
);
3993 return WINDOW_TOTAL_COLS (p
);
3998 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4000 #define CURSIZE(w) \
4001 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4004 /* Enlarge WINDOW by DELTA. HORIZ_FLAG nonzero means enlarge it
4005 horizontally; zero means do it vertically.
4007 Siblings of the selected window are resized to fulfill the size
4008 request. If they become too small in the process, they may be
4012 enlarge_window (Lisp_Object window
, int delta
, int horiz_flag
)
4014 Lisp_Object parent
, next
, prev
;
4018 int (*sizefun
) (Lisp_Object
)
4019 = horiz_flag
? window_width
: window_height
;
4020 void (*setsizefun
) (Lisp_Object
, int, int)
4021 = (horiz_flag
? set_window_width
: set_window_height
);
4023 /* Give up if this window cannot be resized. */
4024 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4025 error ("Window is not resizable");
4027 /* Find the parent of the selected window. */
4030 p
= XWINDOW (window
);
4036 error ("No other window to side of this one");
4041 ? !NILP (XWINDOW (parent
)->hchild
)
4042 : !NILP (XWINDOW (parent
)->vchild
))
4048 sizep
= &CURSIZE (window
);
4051 register int maxdelta
;
4053 /* Compute the maximum size increment this window can have. */
4055 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4056 /* This is a main window followed by a minibuffer. */
4057 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4058 - window_min_size (XWINDOW (p
->next
),
4059 horiz_flag
, 0, 0, 0))
4060 /* This is a minibuffer following a main window. */
4061 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4062 - window_min_size (XWINDOW (p
->prev
),
4063 horiz_flag
, 0, 0, 0))
4064 /* This is a frame with only one window, a minibuffer-only
4065 or a minibufferless frame. */
4068 if (delta
> maxdelta
)
4069 /* This case traps trying to make the minibuffer
4070 the full frame, or make the only window aside from the
4071 minibuffer the full frame. */
4075 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
),
4076 horiz_flag
, 0, 0, 0))
4078 delete_window (window
);
4085 /* Find the total we can get from other siblings without deleting them. */
4087 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4088 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4089 horiz_flag
, 0, 0, 0);
4090 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4091 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4092 horiz_flag
, 0, 0, 0);
4094 /* If we can get it all from them without deleting them, do so. */
4095 if (delta
<= maximum
)
4097 Lisp_Object first_unaffected
;
4098 Lisp_Object first_affected
;
4103 first_affected
= window
;
4104 /* Look at one sibling at a time,
4105 moving away from this window in both directions alternately,
4106 and take as much as we can get without deleting that sibling. */
4108 && (!NILP (next
) || !NILP (prev
)))
4112 int this_one
= ((*sizefun
) (next
)
4113 - window_min_size (XWINDOW (next
), horiz_flag
,
4117 if (this_one
> delta
)
4120 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4121 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4126 next
= XWINDOW (next
)->next
;
4134 int this_one
= ((*sizefun
) (prev
)
4135 - window_min_size (XWINDOW (prev
), horiz_flag
,
4139 if (this_one
> delta
)
4142 first_affected
= prev
;
4144 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4145 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4150 prev
= XWINDOW (prev
)->prev
;
4154 xassert (delta
== 0);
4156 /* Now recalculate the edge positions of all the windows affected,
4157 based on the new sizes. */
4158 first_unaffected
= next
;
4159 prev
= first_affected
;
4160 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4161 prev
= next
, next
= XWINDOW (next
)->next
)
4163 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4164 /* This does not change size of NEXT,
4165 but it propagates the new top edge to its children */
4166 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4171 register int delta1
;
4172 register int opht
= (*sizefun
) (parent
);
4174 if (opht
<= XINT (*sizep
) + delta
)
4176 /* If trying to grow this window to or beyond size of the parent,
4177 just delete all the sibling windows. */
4178 Lisp_Object start
, tem
, next
;
4180 start
= XWINDOW (parent
)->vchild
;
4182 start
= XWINDOW (parent
)->hchild
;
4184 /* Delete any siblings that come after WINDOW. */
4185 tem
= XWINDOW (window
)->next
;
4186 while (! NILP (tem
))
4188 next
= XWINDOW (tem
)->next
;
4189 delete_window (tem
);
4193 /* Delete any siblings that come after WINDOW.
4194 Note that if START is not WINDOW, then WINDOW still
4195 has siblings, so WINDOW has not yet replaced its parent. */
4197 while (! EQ (tem
, window
))
4199 next
= XWINDOW (tem
)->next
;
4200 delete_window (tem
);
4206 /* Otherwise, make delta1 just right so that if we add
4207 delta1 lines to this window and to the parent, and then
4208 shrink the parent back to its original size, the new
4209 proportional size of this window will increase by delta.
4211 The function size_window will compute the new height h'
4212 of the window from delta1 as:
4215 x = delta1 - delta1/n * n for the 1st resizable child
4218 where n is the number of children that can be resized.
4219 We can ignore x by choosing a delta1 that is a multiple of
4220 n. We want the height of this window to come out as
4230 The number of children n equals the number of resizable
4231 children of this window + 1 because we know window itself
4232 is resizable (otherwise we would have signaled an error).
4234 This reasoning is not correct when other windows become too
4235 small and shrink_windows refuses to delete them. Below we
4236 use resize_proportionally to work around this problem. */
4238 struct window
*w
= XWINDOW (window
);
4242 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4243 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4245 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4246 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4251 /* Add delta1 lines or columns to this window, and to the parent,
4252 keeping things consistent while not affecting siblings. */
4253 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4254 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4256 /* Squeeze out delta1 lines or columns from our parent,
4257 shrinking this window and siblings proportionately. This
4258 brings parent back to correct size. Delta1 was calculated
4259 so this makes this window the desired size, taking it all
4260 out of the siblings.
4262 Temporarily set resize_proportionally to Qt to assure that,
4263 if necessary, shrink_windows deletes smaller windows rather
4264 than shrink this window. */
4265 w
->resize_proportionally
= Qt
;
4266 (*setsizefun
) (parent
, opht
, 0);
4267 w
->resize_proportionally
= Qnil
;
4271 XSETFASTINT (p
->last_modified
, 0);
4272 XSETFASTINT (p
->last_overlay_modified
, 0);
4274 /* Adjust glyph matrices. */
4275 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4279 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4280 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4281 zero means adjust the height, moving the bottom edge.
4283 Following siblings of the selected window are resized to fulfill
4284 the size request. If they become too small in the process, they
4285 are not deleted; instead, we signal an error. */
4288 adjust_window_trailing_edge (Lisp_Object window
, int delta
, int horiz_flag
)
4290 Lisp_Object parent
, child
;
4292 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4293 int delcount
= window_deletion_count
;
4295 CHECK_WINDOW (window
);
4297 /* Give up if this window cannot be resized. */
4298 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4299 error ("Window is not resizable");
4303 Lisp_Object first_parallel
= Qnil
;
4307 /* This happens if WINDOW on the previous iteration was
4308 at top level of the window tree. */
4309 Fset_window_configuration (old_config
);
4310 error ("Specified window edge is fixed");
4313 p
= XWINDOW (window
);
4316 /* See if this level has windows in parallel in the specified
4317 direction. If so, set FIRST_PARALLEL to the first one. */
4320 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4321 first_parallel
= XWINDOW (parent
)->vchild
;
4322 else if (NILP (parent
) && !NILP (p
->next
))
4324 /* Handle the vertical chain of main window and minibuffer
4325 which has no parent. */
4326 first_parallel
= window
;
4327 while (! NILP (XWINDOW (first_parallel
)->prev
))
4328 first_parallel
= XWINDOW (first_parallel
)->prev
;
4333 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4334 first_parallel
= XWINDOW (parent
)->hchild
;
4337 /* If this level's succession is in the desired dimension,
4338 and this window is the last one, and there is no higher level,
4339 its trailing edge is fixed. */
4340 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4343 Fset_window_configuration (old_config
);
4344 error ("Specified window edge is fixed");
4347 /* Don't make this window too small. */
4348 if (XINT (CURSIZE (window
)) + delta
4349 < window_min_size_2 (XWINDOW (window
), horiz_flag
, 0))
4351 Fset_window_configuration (old_config
);
4352 error ("Cannot adjust window size as specified");
4355 /* Clear out some redisplay caches. */
4356 XSETFASTINT (p
->last_modified
, 0);
4357 XSETFASTINT (p
->last_overlay_modified
, 0);
4359 /* Adjust this window's edge. */
4360 XSETINT (CURSIZE (window
),
4361 XINT (CURSIZE (window
)) + delta
);
4363 /* If this window has following siblings in the desired dimension,
4364 make them smaller, and exit the loop.
4366 (If we reach the top of the tree and can never do this,
4367 we will fail and report an error, above.) */
4368 if (NILP (first_parallel
))
4370 if (!NILP (p
->next
))
4372 /* This may happen for the minibuffer. In that case
4373 the window_deletion_count check below does not work. */
4374 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4376 Fset_window_configuration (old_config
);
4377 error ("Cannot adjust window size as specified");
4380 XSETINT (CURBEG (p
->next
),
4381 XINT (CURBEG (p
->next
)) + delta
);
4382 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4383 horiz_flag
, 0, 1, 0);
4388 /* Here we have a chain of parallel siblings, in the other dimension.
4389 Change the size of the other siblings. */
4390 for (child
= first_parallel
;
4392 child
= XWINDOW (child
)->next
)
4393 if (! EQ (child
, window
))
4394 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4395 horiz_flag
, 0, 0, 1);
4400 /* If we made a window so small it got deleted,
4401 we failed. Report failure. */
4402 if (delcount
!= window_deletion_count
)
4404 Fset_window_configuration (old_config
);
4405 error ("Cannot adjust window size as specified");
4408 /* Adjust glyph matrices. */
4409 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4415 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4416 Sadjust_window_trailing_edge
, 3, 3, 0,
4417 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4418 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4419 Otherwise, adjust the height, moving the bottom edge.
4421 Following siblings of the selected window are resized to fulfill
4422 the size request. If they become too small in the process, they
4423 are not deleted; instead, we signal an error. */)
4424 (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
)
4426 CHECK_NUMBER (delta
);
4428 window
= selected_window
;
4429 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4431 run_window_configuration_change_hook
4432 (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4439 /***********************************************************************
4440 Resizing Mini-Windows
4441 ***********************************************************************/
4443 static void shrink_window_lowest_first (struct window
*, int);
4445 enum save_restore_action
4452 static int save_restore_orig_size (struct window
*,
4453 enum save_restore_action
);
4455 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4456 from lowest windows first. */
4459 shrink_window_lowest_first (struct window
*w
, int height
)
4465 xassert (!MINI_WINDOW_P (w
));
4467 /* Set redisplay hints. */
4468 XSETFASTINT (w
->last_modified
, 0);
4469 XSETFASTINT (w
->last_overlay_modified
, 0);
4470 windows_or_buffers_changed
++;
4471 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4473 old_height
= XFASTINT (w
->total_lines
);
4474 XSETFASTINT (w
->total_lines
, height
);
4476 if (!NILP (w
->hchild
))
4478 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4480 c
= XWINDOW (child
);
4481 c
->top_line
= w
->top_line
;
4482 shrink_window_lowest_first (c
, height
);
4485 else if (!NILP (w
->vchild
))
4487 Lisp_Object last_child
;
4488 int delta
= old_height
- height
;
4493 /* Find the last child. We are taking space from lowest windows
4494 first, so we iterate over children from the last child
4496 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4499 /* Size children down to their safe heights. */
4500 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4504 c
= XWINDOW (child
);
4505 this_one
= XFASTINT (c
->total_lines
) - window_min_size_1 (c
, 0, 1);
4507 if (this_one
> delta
)
4510 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4514 /* Compute new positions. */
4515 last_top
= XINT (w
->top_line
);
4516 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4518 c
= XWINDOW (child
);
4519 c
->top_line
= make_number (last_top
);
4520 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4521 last_top
+= XFASTINT (c
->total_lines
);
4527 /* Save, restore, or check positions and sizes in the window tree
4528 rooted at W. ACTION says what to do.
4530 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4531 orig_total_lines members are valid for all windows in the window
4532 tree. Value is non-zero if they are valid.
4534 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4535 orig_top_line and orig_total_lines for all windows in the tree.
4537 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4538 stored in orig_top_line and orig_total_lines for all windows. */
4541 save_restore_orig_size (struct window
*w
, enum save_restore_action action
)
4547 if (!NILP (w
->hchild
))
4549 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4552 else if (!NILP (w
->vchild
))
4554 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4560 case CHECK_ORIG_SIZES
:
4561 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4565 case SAVE_ORIG_SIZES
:
4566 w
->orig_top_line
= w
->top_line
;
4567 w
->orig_total_lines
= w
->total_lines
;
4568 XSETFASTINT (w
->last_modified
, 0);
4569 XSETFASTINT (w
->last_overlay_modified
, 0);
4572 case RESTORE_ORIG_SIZES
:
4573 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4574 w
->top_line
= w
->orig_top_line
;
4575 w
->total_lines
= w
->orig_total_lines
;
4576 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4577 XSETFASTINT (w
->last_modified
, 0);
4578 XSETFASTINT (w
->last_overlay_modified
, 0);
4585 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4592 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4593 without deleting other windows. */
4596 grow_mini_window (struct window
*w
, int delta
)
4598 struct frame
*f
= XFRAME (w
->frame
);
4599 struct window
*root
;
4601 xassert (MINI_WINDOW_P (w
));
4602 /* Commenting out the following assertion goes against the stated interface
4603 of the function, but it currently does not seem to do anything useful.
4604 See discussion of this issue in the thread for bug#4534.
4605 xassert (delta >= 0); */
4607 /* Compute how much we can enlarge the mini-window without deleting
4609 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4612 int min_height
= window_min_size (root
, 0, 0, 0, 0);
4613 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4614 /* Note that the root window may already be smaller than
4616 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4621 /* Save original window sizes and positions, if not already done. */
4622 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4623 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4625 /* Shrink other windows. */
4626 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4628 /* Grow the mini-window. */
4629 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4630 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4631 XSETFASTINT (w
->last_modified
, 0);
4632 XSETFASTINT (w
->last_overlay_modified
, 0);
4639 /* Shrink mini-window W. If there is recorded info about window sizes
4640 before a call to grow_mini_window, restore recorded window sizes.
4641 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4645 shrink_mini_window (struct window
*w
)
4647 struct frame
*f
= XFRAME (w
->frame
);
4648 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4650 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4652 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4654 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4655 windows_or_buffers_changed
= 1;
4657 else if (XFASTINT (w
->total_lines
) > 1)
4659 /* Distribute the additional lines of the mini-window
4660 among the other windows. */
4662 XSETWINDOW (window
, w
);
4663 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4669 /* Mark window cursors off for all windows in the window tree rooted
4670 at W by setting their phys_cursor_on_p flag to zero. Called from
4671 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4672 the frame are cleared. */
4675 mark_window_cursors_off (struct window
*w
)
4679 if (!NILP (w
->hchild
))
4680 mark_window_cursors_off (XWINDOW (w
->hchild
));
4681 else if (!NILP (w
->vchild
))
4682 mark_window_cursors_off (XWINDOW (w
->vchild
));
4684 w
->phys_cursor_on_p
= 0;
4686 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4691 /* Return number of lines of text (not counting mode lines) in W. */
4694 window_internal_height (struct window
*w
)
4696 int ht
= XFASTINT (w
->total_lines
);
4698 if (!MINI_WINDOW_P (w
))
4700 if (!NILP (w
->parent
)
4701 || !NILP (w
->vchild
)
4702 || !NILP (w
->hchild
)
4705 || WINDOW_WANTS_MODELINE_P (w
))
4708 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4716 /* Return the number of columns in W.
4717 Don't count columns occupied by scroll bars or the vertical bar
4718 separating W from the sibling to its right. */
4721 window_box_text_cols (struct window
*w
)
4723 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4724 int width
= XINT (w
->total_cols
);
4726 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4727 /* Scroll bars occupy a few columns. */
4728 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4729 else if (!FRAME_WINDOW_P (f
)
4730 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4731 /* The column of `|' characters separating side-by-side windows
4732 occupies one column only. */
4735 if (FRAME_WINDOW_P (f
))
4736 /* On window-systems, fringes and display margins cannot be
4737 used for normal text. */
4738 width
-= (WINDOW_FRINGE_COLS (w
)
4739 + WINDOW_LEFT_MARGIN_COLS (w
)
4740 + WINDOW_RIGHT_MARGIN_COLS (w
));
4746 /************************************************************************
4748 ***********************************************************************/
4750 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4751 N screen-fulls, which is defined as the height of the window minus
4752 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4753 instead. Negative values of N mean scroll down. NOERROR non-zero
4754 means don't signal an error if we try to move over BEGV or ZV,
4758 window_scroll (Lisp_Object window
, int n
, int whole
, int noerror
)
4762 /* If we must, use the pixel-based version which is much slower than
4763 the line-based one but can handle varying line heights. */
4764 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4765 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4767 window_scroll_line_based (window
, n
, whole
, noerror
);
4773 /* Implementation of window_scroll that works based on pixel line
4774 heights. See the comment of window_scroll for parameter
4778 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4781 struct window
*w
= XWINDOW (window
);
4782 struct text_pos start
;
4783 int this_scroll_margin
;
4784 /* True if we fiddled the window vscroll field without really scrolling. */
4786 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4788 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4790 /* If PT is not visible in WINDOW, move back one half of
4791 the screen. Allow PT to be partially visible, otherwise
4792 something like (scroll-down 1) with PT in the line before
4793 the partially visible one would recenter. */
4795 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4797 /* Move backward half the height of the window. Performance note:
4798 vmotion used here is about 10% faster, but would give wrong
4799 results for variable height lines. */
4800 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4801 it
.current_y
= it
.last_visible_y
;
4802 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4804 /* The function move_iterator_vertically may move over more than
4805 the specified y-distance. If it->w is small, e.g. a
4806 mini-buffer window, we may end up in front of the window's
4807 display area. This is the case when Start displaying at the
4808 start of the line containing PT in this case. */
4809 if (it
.current_y
<= 0)
4811 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4812 move_it_vertically_backward (&it
, 0);
4816 start
= it
.current
.pos
;
4818 else if (auto_window_vscroll_p
)
4820 if (rtop
|| rbot
) /* partially visible */
4823 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4825 dy
= max ((window_box_height (w
)
4826 - next_screen_context_lines
* dy
),
4832 /* Only vscroll backwards if already vscrolled forwards. */
4833 if (w
->vscroll
< 0 && rtop
> 0)
4835 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4836 Fset_window_vscroll (window
, make_number (px
), Qt
);
4842 /* Do vscroll if already vscrolled or only display line. */
4843 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4845 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4846 Fset_window_vscroll (window
, make_number (px
), Qt
);
4850 /* Maybe modify window start instead of scrolling. */
4851 if (rbot
> 0 || w
->vscroll
< 0)
4855 Fset_window_vscroll (window
, make_number (0), Qt
);
4856 /* If there are other text lines above the current row,
4857 move window start to current row. Else to next row. */
4859 spos
= XINT (Fline_beginning_position (Qnil
));
4861 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4862 set_marker_restricted (w
->start
, make_number (spos
),
4864 w
->start_at_line_beg
= Qt
;
4865 w
->update_mode_line
= Qt
;
4866 XSETFASTINT (w
->last_modified
, 0);
4867 XSETFASTINT (w
->last_overlay_modified
, 0);
4868 /* Set force_start so that redisplay_window will run the
4869 window-scroll-functions. */
4870 w
->force_start
= Qt
;
4875 /* Cancel previous vscroll. */
4876 Fset_window_vscroll (window
, make_number (0), Qt
);
4879 /* If scroll_preserve_screen_position is non-nil, we try to set
4880 point in the same window line as it is now, so get that line. */
4881 if (!NILP (Vscroll_preserve_screen_position
))
4883 /* We preserve the goal pixel coordinate across consecutive
4884 calls to scroll-up, scroll-down and other commands that
4885 have the `scroll-command' property. This avoids the
4886 possibility of point becoming "stuck" on a tall line when
4887 scrolling by one line. */
4888 if (window_scroll_pixel_based_preserve_y
< 0
4889 || !SYMBOLP (current_kboard
->Vlast_command
)
4890 || NILP (Fget (current_kboard
->Vlast_command
, Qscroll_command
)))
4892 start_display (&it
, w
, start
);
4893 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4894 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4895 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4899 window_scroll_pixel_based_preserve_y
4900 = window_scroll_pixel_based_preserve_x
= -1;
4902 /* Move iterator it from start the specified distance forward or
4903 backward. The result is the new window start. */
4904 start_display (&it
, w
, start
);
4907 int start_pos
= IT_CHARPOS (it
);
4908 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4909 dy
= max ((window_box_height (w
)
4910 - next_screen_context_lines
* dy
),
4913 /* Note that move_it_vertically always moves the iterator to the
4914 start of a line. So, if the last line doesn't have a newline,
4915 we would end up at the start of the line ending at ZV. */
4918 move_it_vertically_backward (&it
, -dy
);
4919 /* Ensure we actually do move, e.g. in case we are currently
4920 looking at an image that is taller that the window height. */
4921 while (start_pos
== IT_CHARPOS (it
)
4922 && start_pos
> BEGV
)
4923 move_it_by_lines (&it
, -1, 1);
4927 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4928 MOVE_TO_POS
| MOVE_TO_Y
);
4929 /* Ensure we actually do move, e.g. in case we are currently
4930 looking at an image that is taller that the window height. */
4931 while (start_pos
== IT_CHARPOS (it
)
4933 move_it_by_lines (&it
, 1, 1);
4937 move_it_by_lines (&it
, n
, 1);
4939 /* We failed if we find ZV is already on the screen (scrolling up,
4940 means there's nothing past the end), or if we can't start any
4941 earlier (scrolling down, means there's nothing past the top). */
4942 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4943 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4945 if (IT_CHARPOS (it
) == ZV
)
4947 if (it
.current_y
< it
.last_visible_y
4948 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4949 > it
.last_visible_y
))
4951 /* The last line was only partially visible, make it fully
4953 w
->vscroll
= (it
.last_visible_y
4954 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4955 adjust_glyphs (it
.f
);
4959 else if (n
< 0) /* could happen with empty buffers */
4960 xsignal0 (Qbeginning_of_buffer
);
4962 xsignal0 (Qend_of_buffer
);
4966 if (w
->vscroll
!= 0)
4967 /* The first line was only partially visible, make it fully
4973 xsignal0 (Qbeginning_of_buffer
);
4976 /* If control gets here, then we vscrolled. */
4978 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4980 /* Don't try to change the window start below. */
4986 int pos
= IT_CHARPOS (it
);
4989 /* If in the middle of a multi-glyph character move forward to
4990 the next character. */
4991 if (in_display_vector_p (&it
))
4994 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4997 /* Set the window start, and set up the window for redisplay. */
4998 set_marker_restricted (w
->start
, make_number (pos
),
5000 bytepos
= XMARKER (w
->start
)->bytepos
;
5001 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5003 w
->update_mode_line
= Qt
;
5004 XSETFASTINT (w
->last_modified
, 0);
5005 XSETFASTINT (w
->last_overlay_modified
, 0);
5006 /* Set force_start so that redisplay_window will run the
5007 window-scroll-functions. */
5008 w
->force_start
= Qt
;
5011 /* The rest of this function uses current_y in a nonstandard way,
5012 not including the height of the header line if any. */
5013 it
.current_y
= it
.vpos
= 0;
5015 /* Move PT out of scroll margins.
5016 This code wants current_y to be zero at the window start position
5017 even if there is a header line. */
5018 this_scroll_margin
= max (0, scroll_margin
);
5019 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5020 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5024 /* We moved the window start towards ZV, so PT may be now
5025 in the scroll margin at the top. */
5026 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5027 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5028 && (NILP (Vscroll_preserve_screen_position
)
5029 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5030 /* We found PT at a legitimate height. Leave it alone. */
5032 else if (window_scroll_pixel_based_preserve_y
>= 0)
5034 /* If we have a header line, take account of it.
5035 This is necessary because we set it.current_y to 0, above. */
5036 move_it_to (&it
, -1,
5037 window_scroll_pixel_based_preserve_x
,
5038 window_scroll_pixel_based_preserve_y
5039 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5040 -1, MOVE_TO_Y
| MOVE_TO_X
);
5041 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5045 while (it
.current_y
< this_scroll_margin
)
5047 int prev
= it
.current_y
;
5048 move_it_by_lines (&it
, 1, 1);
5049 if (prev
== it
.current_y
)
5052 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5057 int charpos
, bytepos
;
5060 /* Save our position, for the
5061 window_scroll_pixel_based_preserve_y case. */
5062 charpos
= IT_CHARPOS (it
);
5063 bytepos
= IT_BYTEPOS (it
);
5065 /* We moved the window start towards BEGV, so PT may be now
5066 in the scroll margin at the bottom. */
5067 move_it_to (&it
, PT
, -1,
5068 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5069 - this_scroll_margin
- 1),
5071 MOVE_TO_POS
| MOVE_TO_Y
);
5073 /* Save our position, in case it's correct. */
5074 charpos
= IT_CHARPOS (it
);
5075 bytepos
= IT_BYTEPOS (it
);
5077 /* See if point is on a partially visible line at the end. */
5078 if (it
.what
== IT_EOB
)
5079 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5082 move_it_by_lines (&it
, 1, 1);
5083 partial_p
= it
.current_y
> it
.last_visible_y
;
5086 if (charpos
== PT
&& !partial_p
5087 && (NILP (Vscroll_preserve_screen_position
)
5088 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5089 /* We found PT before we found the display margin, so PT is ok. */
5091 else if (window_scroll_pixel_based_preserve_y
>= 0)
5093 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5094 start_display (&it
, w
, start
);
5095 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5096 here because we called start_display again and did not
5097 alter it.current_y this time. */
5098 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
5099 window_scroll_pixel_based_preserve_y
, -1,
5100 MOVE_TO_Y
| MOVE_TO_X
);
5101 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5106 /* The last line was only partially visible, so back up two
5107 lines to make sure we're on a fully visible line. */
5109 move_it_by_lines (&it
, -2, 0);
5110 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5113 /* No, the position we saved is OK, so use it. */
5114 SET_PT_BOTH (charpos
, bytepos
);
5120 /* Implementation of window_scroll that works based on screen lines.
5121 See the comment of window_scroll for parameter descriptions. */
5124 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
5126 register struct window
*w
= XWINDOW (window
);
5127 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5128 register int pos
, pos_byte
;
5129 register int ht
= window_internal_height (w
);
5130 register Lisp_Object tem
;
5134 Lisp_Object original_pos
= Qnil
;
5136 /* If scrolling screen-fulls, compute the number of lines to
5137 scroll from the window's height. */
5139 n
*= max (1, ht
- next_screen_context_lines
);
5141 startpos
= marker_position (w
->start
);
5143 if (!NILP (Vscroll_preserve_screen_position
))
5145 if (window_scroll_preserve_vpos
<= 0
5146 || !SYMBOLP (current_kboard
->Vlast_command
)
5147 || NILP (Fget (current_kboard
->Vlast_command
, Qscroll_command
)))
5149 struct position posit
5150 = *compute_motion (startpos
, 0, 0, 0,
5152 -1, XINT (w
->hscroll
),
5154 window_scroll_preserve_vpos
= posit
.vpos
;
5155 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
5158 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
5159 make_number (window_scroll_preserve_vpos
));
5162 XSETFASTINT (tem
, PT
);
5163 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5167 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5172 lose
= n
< 0 && PT
== BEGV
;
5173 Fvertical_motion (make_number (n
), window
);
5177 SET_PT_BOTH (opoint
, opoint_byte
);
5184 xsignal0 (Qbeginning_of_buffer
);
5189 int this_scroll_margin
= scroll_margin
;
5191 /* Don't use a scroll margin that is negative or too large. */
5192 if (this_scroll_margin
< 0)
5193 this_scroll_margin
= 0;
5195 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5196 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5198 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5199 w
->start_at_line_beg
= bolp
;
5200 w
->update_mode_line
= Qt
;
5201 XSETFASTINT (w
->last_modified
, 0);
5202 XSETFASTINT (w
->last_overlay_modified
, 0);
5203 /* Set force_start so that redisplay_window will run
5204 the window-scroll-functions. */
5205 w
->force_start
= Qt
;
5207 if (!NILP (Vscroll_preserve_screen_position
)
5208 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5210 SET_PT_BOTH (pos
, pos_byte
);
5211 Fvertical_motion (original_pos
, window
);
5213 /* If we scrolled forward, put point enough lines down
5214 that it is outside the scroll margin. */
5219 if (this_scroll_margin
> 0)
5221 SET_PT_BOTH (pos
, pos_byte
);
5222 Fvertical_motion (make_number (this_scroll_margin
), window
);
5228 if (top_margin
<= opoint
)
5229 SET_PT_BOTH (opoint
, opoint_byte
);
5230 else if (!NILP (Vscroll_preserve_screen_position
))
5232 SET_PT_BOTH (pos
, pos_byte
);
5233 Fvertical_motion (original_pos
, window
);
5236 SET_PT (top_margin
);
5242 /* If we scrolled backward, put point near the end of the window
5243 but not within the scroll margin. */
5244 SET_PT_BOTH (pos
, pos_byte
);
5245 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5246 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5249 bottom_margin
= PT
+ 1;
5251 if (bottom_margin
> opoint
)
5252 SET_PT_BOTH (opoint
, opoint_byte
);
5255 if (!NILP (Vscroll_preserve_screen_position
))
5257 SET_PT_BOTH (pos
, pos_byte
);
5258 Fvertical_motion (original_pos
, window
);
5261 Fvertical_motion (make_number (-1), window
);
5270 xsignal0 (Qend_of_buffer
);
5275 /* Scroll selected_window up or down. If N is nil, scroll a
5276 screen-full which is defined as the height of the window minus
5277 next_screen_context_lines. If N is the symbol `-', scroll.
5278 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5279 up. This is the guts of Fscroll_up and Fscroll_down. */
5282 scroll_command (Lisp_Object n
, int direction
)
5284 int count
= SPECPDL_INDEX ();
5286 xassert (eabs (direction
) == 1);
5288 /* If selected window's buffer isn't current, make it current for
5289 the moment. But don't screw up if window_scroll gets an error. */
5290 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5292 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5293 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5295 /* Make redisplay consider other windows than just selected_window. */
5296 ++windows_or_buffers_changed
;
5300 window_scroll (selected_window
, direction
, 1, 0);
5301 else if (EQ (n
, Qminus
))
5302 window_scroll (selected_window
, -direction
, 1, 0);
5305 n
= Fprefix_numeric_value (n
);
5306 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5309 unbind_to (count
, Qnil
);
5312 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
5313 doc
: /* Scroll text of selected window upward ARG lines.
5314 If ARG is omitted or nil, scroll upward by a near full screen.
5315 A near full screen is `next-screen-context-lines' less than a full screen.
5316 Negative ARG means scroll downward.
5317 If ARG is the atom `-', scroll downward by nearly full screen.
5318 When calling from a program, supply as argument a number, nil, or `-'. */)
5321 scroll_command (arg
, 1);
5325 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
5326 doc
: /* Scroll text of selected window down ARG lines.
5327 If ARG is omitted or nil, scroll down by a near full screen.
5328 A near full screen is `next-screen-context-lines' less than a full screen.
5329 Negative ARG means scroll upward.
5330 If ARG is the atom `-', scroll upward by nearly full screen.
5331 When calling from a program, supply as argument a number, nil, or `-'. */)
5334 scroll_command (arg
, -1);
5338 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5339 doc
: /* Return the other window for \"other window scroll\" commands.
5340 If `other-window-scroll-buffer' is non-nil, a window
5341 showing that buffer is used.
5342 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5343 specifies the window. This takes precedence over
5344 `other-window-scroll-buffer'. */)
5349 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5350 && !NILP (Vminibuf_scroll_window
))
5351 window
= Vminibuf_scroll_window
;
5352 /* If buffer is specified, scroll that buffer. */
5353 else if (!NILP (Vother_window_scroll_buffer
))
5355 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5357 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5361 /* Nothing specified; look for a neighboring window on the same
5363 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5365 if (EQ (window
, selected_window
))
5366 /* That didn't get us anywhere; look for a window on another
5369 window
= Fnext_window (window
, Qnil
, Qt
);
5370 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5371 && ! EQ (window
, selected_window
));
5374 CHECK_LIVE_WINDOW (window
);
5376 if (EQ (window
, selected_window
))
5377 error ("There is no other window");
5382 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5383 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5384 A near full screen is `next-screen-context-lines' less than a full screen.
5385 The next window is the one below the current one; or the one at the top
5386 if the current one is at the bottom. Negative ARG means scroll downward.
5387 If ARG is the atom `-', scroll downward by nearly full screen.
5388 When calling from a program, supply as argument a number, nil, or `-'.
5390 If `other-window-scroll-buffer' is non-nil, scroll the window
5391 showing that buffer, popping the buffer up if necessary.
5392 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5393 specifies the window to scroll. This takes precedence over
5394 `other-window-scroll-buffer'. */)
5399 int count
= SPECPDL_INDEX ();
5401 window
= Fother_window_for_scrolling ();
5402 w
= XWINDOW (window
);
5404 /* Don't screw up if window_scroll gets an error. */
5405 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5406 ++windows_or_buffers_changed
;
5408 Fset_buffer (w
->buffer
);
5409 SET_PT (marker_position (w
->pointm
));
5412 window_scroll (window
, 1, 1, 1);
5413 else if (EQ (arg
, Qminus
))
5414 window_scroll (window
, -1, 1, 1);
5420 window_scroll (window
, XINT (arg
), 0, 1);
5423 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5424 unbind_to (count
, Qnil
);
5429 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5430 doc
: /* Scroll selected window display ARG columns left.
5431 Default for ARG is window width minus 2.
5432 Value is the total amount of leftward horizontal scrolling in
5433 effect after the change.
5434 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5435 lower bound for automatic scrolling, i.e. automatic scrolling
5436 will not scroll a window to a column less than the value returned
5437 by this function. This happens in an interactive call. */)
5438 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5442 struct window
*w
= XWINDOW (selected_window
);
5445 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5447 arg
= Fprefix_numeric_value (arg
);
5449 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5450 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5452 if (!NILP (set_minimum
))
5453 w
->min_hscroll
= w
->hscroll
;
5458 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5459 doc
: /* Scroll selected window display ARG columns right.
5460 Default for ARG is window width minus 2.
5461 Value is the total amount of leftward horizontal scrolling in
5462 effect after the change.
5463 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5464 lower bound for automatic scrolling, i.e. automatic scrolling
5465 will not scroll a window to a column less than the value returned
5466 by this function. This happens in an interactive call. */)
5467 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5471 struct window
*w
= XWINDOW (selected_window
);
5474 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5476 arg
= Fprefix_numeric_value (arg
);
5478 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5479 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5481 if (!NILP (set_minimum
))
5482 w
->min_hscroll
= w
->hscroll
;
5487 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5488 doc
: /* Return the window which was selected when entering the minibuffer.
5489 Returns nil, if selected window is not a minibuffer window. */)
5492 if (minibuf_level
> 0
5493 && MINI_WINDOW_P (XWINDOW (selected_window
))
5494 && WINDOW_LIVE_P (minibuf_selected_window
))
5495 return minibuf_selected_window
;
5500 /* Value is the number of lines actually displayed in window W,
5501 as opposed to its height. */
5504 displayed_window_lines (struct window
*w
)
5507 struct text_pos start
;
5508 int height
= window_box_height (w
);
5509 struct buffer
*old_buffer
;
5512 if (XBUFFER (w
->buffer
) != current_buffer
)
5514 old_buffer
= current_buffer
;
5515 set_buffer_internal (XBUFFER (w
->buffer
));
5520 /* In case W->start is out of the accessible range, do something
5521 reasonable. This happens in Info mode when Info-scroll-down
5522 calls (recenter -1) while W->start is 1. */
5523 if (XMARKER (w
->start
)->charpos
< BEGV
)
5524 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5525 else if (XMARKER (w
->start
)->charpos
> ZV
)
5526 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5528 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5530 start_display (&it
, w
, start
);
5531 move_it_vertically (&it
, height
);
5532 bottom_y
= line_bottom_y (&it
);
5534 /* rms: On a non-window display,
5535 the value of it.vpos at the bottom of the screen
5536 seems to be 1 larger than window_box_height (w).
5537 This kludge fixes a bug whereby (move-to-window-line -1)
5538 when ZV is on the last screen line
5539 moves to the previous screen line instead of the last one. */
5540 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5543 /* Add in empty lines at the bottom of the window. */
5544 if (bottom_y
< height
)
5546 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5547 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5551 set_buffer_internal (old_buffer
);
5557 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5558 doc
: /* Center point in selected window and maybe redisplay frame.
5559 With prefix argument ARG, recenter putting point on screen line ARG
5560 relative to the selected window. If ARG is negative, it counts up from the
5561 bottom of the window. (ARG should be less than the height of the window.)
5563 If ARG is omitted or nil, then recenter with point on the middle line of
5564 the selected window; if the variable `recenter-redisplay' is non-nil,
5565 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5566 is set to `grow-only', this resets the tool-bar's height to the minimum
5567 height needed); if `recenter-redisplay' has the special value `tty',
5568 then only tty frame are redrawn.
5570 Just C-u as prefix means put point in the center of the window
5571 and redisplay normally--don't erase and redraw the frame. */)
5572 (register Lisp_Object arg
)
5574 struct window
*w
= XWINDOW (selected_window
);
5575 struct buffer
*buf
= XBUFFER (w
->buffer
);
5576 struct buffer
*obuf
= current_buffer
;
5578 int charpos
, bytepos
;
5580 int this_scroll_margin
;
5582 /* If redisplay is suppressed due to an error, try again. */
5583 obuf
->display_error_modiff
= 0;
5587 if (!NILP (Vrecenter_redisplay
)
5588 && (!EQ (Vrecenter_redisplay
, Qtty
)
5589 || !NILP (Ftty_type (selected_frame
))))
5593 /* Invalidate pixel data calculated for all compositions. */
5594 for (i
= 0; i
< n_compositions
; i
++)
5595 composition_table
[i
]->font
= NULL
;
5597 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5599 Fredraw_frame (WINDOW_FRAME (w
));
5600 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5605 else if (CONSP (arg
)) /* Just C-u. */
5609 arg
= Fprefix_numeric_value (arg
);
5614 set_buffer_internal (buf
);
5616 /* Do this after making BUF current
5617 in case scroll_margin is buffer-local. */
5618 this_scroll_margin
= max (0, scroll_margin
);
5619 this_scroll_margin
= min (this_scroll_margin
,
5620 XFASTINT (w
->total_lines
) / 4);
5622 /* Handle centering on a graphical frame specially. Such frames can
5623 have variable-height lines and centering point on the basis of
5624 line counts would lead to strange effects. */
5625 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5632 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5633 start_display (&it
, w
, pt
);
5634 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5635 charpos
= IT_CHARPOS (it
);
5636 bytepos
= IT_BYTEPOS (it
);
5643 int extra_line_spacing
;
5644 int h
= window_box_height (w
);
5646 iarg
= - max (-iarg
, this_scroll_margin
);
5648 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5649 start_display (&it
, w
, pt
);
5651 /* Be sure we have the exact height of the full line containing PT. */
5652 move_it_by_lines (&it
, 0, 1);
5654 /* The amount of pixels we have to move back is the window
5655 height minus what's displayed in the line containing PT,
5656 and the lines below. */
5659 move_it_by_lines (&it
, nlines
, 1);
5661 if (it
.vpos
== nlines
)
5665 /* Last line has no newline */
5666 h
-= line_bottom_y (&it
);
5670 /* Don't reserve space for extra line spacing of last line. */
5671 extra_line_spacing
= it
.max_extra_line_spacing
;
5673 /* If we can't move down NLINES lines because we hit
5674 the end of the buffer, count in some empty lines. */
5675 if (it
.vpos
< nlines
)
5678 extra_line_spacing
= it
.extra_line_spacing
;
5679 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5684 /* Now find the new top line (starting position) of the window. */
5685 start_display (&it
, w
, pt
);
5687 move_it_vertically_backward (&it
, h
);
5689 /* If extra line spacing is present, we may move too far
5690 back. This causes the last line to be only partially
5691 visible (which triggers redisplay to recenter that line
5692 in the middle), so move forward.
5693 But ignore extra line spacing on last line, as it is not
5694 considered to be part of the visible height of the line.
5696 h
+= extra_line_spacing
;
5697 while (-it
.current_y
> h
)
5698 move_it_by_lines (&it
, 1, 1);
5700 charpos
= IT_CHARPOS (it
);
5701 bytepos
= IT_BYTEPOS (it
);
5705 struct position pos
;
5707 iarg
= max (iarg
, this_scroll_margin
);
5709 pos
= *vmotion (PT
, -iarg
, w
);
5710 charpos
= pos
.bufpos
;
5711 bytepos
= pos
.bytepos
;
5716 struct position pos
;
5717 int ht
= window_internal_height (w
);
5724 /* Don't let it get into the margin at either top or bottom. */
5725 iarg
= max (iarg
, this_scroll_margin
);
5726 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5728 pos
= *vmotion (PT
, - iarg
, w
);
5729 charpos
= pos
.bufpos
;
5730 bytepos
= pos
.bytepos
;
5733 /* Set the new window start. */
5734 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5735 w
->window_end_valid
= Qnil
;
5737 w
->optional_new_start
= Qt
;
5739 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5740 w
->start_at_line_beg
= Qt
;
5742 w
->start_at_line_beg
= Qnil
;
5744 set_buffer_internal (obuf
);
5749 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5751 doc
: /* Return the height in lines of the text display area of WINDOW.
5752 WINDOW defaults to the selected window.
5754 The return value does not include the mode line, any header line, nor
5755 any partial-height lines in the text display area. */)
5756 (Lisp_Object window
)
5758 struct window
*w
= decode_window (window
);
5759 int pixel_height
= window_box_height (w
);
5760 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5761 return make_number (line_height
);
5766 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5768 doc
: /* Position point relative to window.
5769 With no argument, position point at center of window.
5770 An argument specifies vertical position within the window;
5771 zero means top of window, negative means relative to bottom of window. */)
5774 struct window
*w
= XWINDOW (selected_window
);
5778 int this_scroll_margin
;
5781 window
= selected_window
;
5782 start
= marker_position (w
->start
);
5783 if (start
< BEGV
|| start
> ZV
)
5785 int height
= window_internal_height (w
);
5786 Fvertical_motion (make_number (- (height
/ 2)), window
);
5787 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5788 w
->start_at_line_beg
= Fbolp ();
5789 w
->force_start
= Qt
;
5792 Fgoto_char (w
->start
);
5794 lines
= displayed_window_lines (w
);
5797 this_scroll_margin
= max (0, scroll_margin
);
5798 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5802 XSETFASTINT (arg
, lines
/ 2);
5805 int iarg
= XINT (Fprefix_numeric_value (arg
));
5808 iarg
= iarg
+ lines
;
5810 #if 0 /* This code would prevent move-to-window-line from moving point
5811 to a place inside the scroll margins (which would cause the
5812 next redisplay to scroll). I wrote this code, but then concluded
5813 it is probably better not to install it. However, it is here
5814 inside #if 0 so as not to lose it. -- rms. */
5816 /* Don't let it get into the margin at either top or bottom. */
5817 iarg
= max (iarg
, this_scroll_margin
);
5818 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5821 arg
= make_number (iarg
);
5824 /* Skip past a partially visible first line. */
5826 XSETINT (arg
, XINT (arg
) + 1);
5828 return Fvertical_motion (arg
, window
);
5833 /***********************************************************************
5834 Window Configuration
5835 ***********************************************************************/
5837 struct save_window_data
5840 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5841 Lisp_Object selected_frame
;
5842 Lisp_Object current_window
;
5843 Lisp_Object current_buffer
;
5844 Lisp_Object minibuf_scroll_window
;
5845 Lisp_Object minibuf_selected_window
;
5846 Lisp_Object root_window
;
5847 Lisp_Object focus_frame
;
5848 /* A vector, each of whose elements is a struct saved_window
5850 Lisp_Object saved_windows
;
5852 /* All fields above are traced by the GC.
5853 From `fame-cols' down, the fields are ignored by the GC. */
5855 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5856 int frame_tool_bar_lines
;
5859 /* This is saved as a Lisp_Vector */
5862 /* these first two must agree with struct Lisp_Vector in lisp.h */
5864 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5867 Lisp_Object buffer
, start
, pointm
, mark
;
5868 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5869 Lisp_Object hscroll
, min_hscroll
;
5870 Lisp_Object parent
, prev
;
5871 Lisp_Object start_at_line_beg
;
5872 Lisp_Object display_table
;
5873 Lisp_Object orig_top_line
, orig_total_lines
;
5874 Lisp_Object left_margin_cols
, right_margin_cols
;
5875 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5876 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5877 Lisp_Object dedicated
, resize_proportionally
;
5880 #define SAVED_WINDOW_N(swv,n) \
5881 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5883 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5884 doc
: /* Return t if OBJECT is a window-configuration object. */)
5885 (Lisp_Object object
)
5887 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5890 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5891 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5892 (Lisp_Object config
)
5894 register struct save_window_data
*data
;
5895 struct Lisp_Vector
*saved_windows
;
5897 CHECK_WINDOW_CONFIGURATION (config
);
5899 data
= (struct save_window_data
*) XVECTOR (config
);
5900 saved_windows
= XVECTOR (data
->saved_windows
);
5901 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5904 DEFUN ("set-window-configuration", Fset_window_configuration
,
5905 Sset_window_configuration
, 1, 1, 0,
5906 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5907 CONFIGURATION must be a value previously returned
5908 by `current-window-configuration' (which see).
5909 If CONFIGURATION was made from a frame that is now deleted,
5910 only frame-independent values can be restored. In this case,
5911 the return value is nil. Otherwise the value is t. */)
5912 (Lisp_Object configuration
)
5914 register struct save_window_data
*data
;
5915 struct Lisp_Vector
*saved_windows
;
5916 Lisp_Object new_current_buffer
;
5921 CHECK_WINDOW_CONFIGURATION (configuration
);
5923 data
= (struct save_window_data
*) XVECTOR (configuration
);
5924 saved_windows
= XVECTOR (data
->saved_windows
);
5926 new_current_buffer
= data
->current_buffer
;
5927 if (NILP (XBUFFER (new_current_buffer
)->name
))
5928 new_current_buffer
= Qnil
;
5931 if (XBUFFER (new_current_buffer
) == current_buffer
)
5932 /* The code further down "preserves point" by saving here PT in
5933 old_point and then setting it later back into PT. When the
5934 current-selected-window and the final-selected-window both show
5935 the current buffer, this suffers from the problem that the
5936 current PT is the window-point of the current-selected-window,
5937 while the final PT is the point of the final-selected-window, so
5938 this copy from one PT to the other would end up moving the
5939 window-point of the final-selected-window to the window-point of
5940 the current-selected-window. So we have to be careful which
5941 point of the current-buffer we copy into old_point. */
5942 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5943 && WINDOWP (selected_window
)
5944 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5945 && !EQ (selected_window
, data
->current_window
))
5946 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5950 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5951 point in new_current_buffer as of the last time this buffer was
5952 used. This can be non-deterministic since it can be changed by
5953 things like jit-lock by mere temporary selection of some random
5954 window that happens to show this buffer.
5955 So if possible we want this arbitrary choice of "which point" to
5956 be the one from the to-be-selected-window so as to prevent this
5957 window's cursor from being copied from another window. */
5958 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5959 /* If current_window = selected_window, its point is in BUF_PT. */
5960 && !EQ (selected_window
, data
->current_window
))
5961 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5963 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5966 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5969 /* If f is a dead frame, don't bother rebuilding its window tree.
5970 However, there is other stuff we should still try to do below. */
5971 if (FRAME_LIVE_P (f
))
5973 register struct window
*w
;
5974 register struct saved_window
*p
;
5975 struct window
*root_window
;
5976 struct window
**leaf_windows
;
5980 /* If the frame has been resized since this window configuration was
5981 made, we change the frame to the size specified in the
5982 configuration, restore the configuration, and then resize it
5983 back. We keep track of the prevailing height in these variables. */
5984 int previous_frame_lines
= FRAME_LINES (f
);
5985 int previous_frame_cols
= FRAME_COLS (f
);
5986 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5987 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5989 /* The mouse highlighting code could get screwed up
5990 if it runs during this. */
5993 if (data
->frame_lines
!= previous_frame_lines
5994 || data
->frame_cols
!= previous_frame_cols
)
5995 change_frame_size (f
, data
->frame_lines
,
5996 data
->frame_cols
, 0, 0, 0);
5997 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5998 if (data
->frame_menu_bar_lines
5999 != previous_frame_menu_bar_lines
)
6000 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
6002 #ifdef HAVE_WINDOW_SYSTEM
6003 if (data
->frame_tool_bar_lines
6004 != previous_frame_tool_bar_lines
)
6005 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
6010 /* "Swap out" point from the selected window's buffer
6011 into the window itself. (Normally the pointm of the selected
6012 window holds garbage.) We do this now, before
6013 restoring the window contents, and prevent it from
6014 being done later on when we select a new window. */
6015 if (! NILP (XWINDOW (selected_window
)->buffer
))
6017 w
= XWINDOW (selected_window
);
6018 set_marker_both (w
->pointm
,
6020 BUF_PT (XBUFFER (w
->buffer
)),
6021 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6024 windows_or_buffers_changed
++;
6025 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6027 /* Problem: Freeing all matrices and later allocating them again
6028 is a serious redisplay flickering problem. What we would
6029 really like to do is to free only those matrices not reused
6031 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6033 = (struct window
**) alloca (count_windows (root_window
)
6034 * sizeof (struct window
*));
6035 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6038 Mark all windows now on frame as "deleted".
6039 Restoring the new configuration "undeletes" any that are in it.
6041 Save their current buffers in their height fields, since we may
6042 need it later, if a buffer saved in the configuration is now
6044 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6046 for (k
= 0; k
< saved_windows
->size
; k
++)
6048 p
= SAVED_WINDOW_N (saved_windows
, k
);
6049 w
= XWINDOW (p
->window
);
6052 if (!NILP (p
->parent
))
6053 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6054 XFASTINT (p
->parent
))->window
;
6058 if (!NILP (p
->prev
))
6060 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6061 XFASTINT (p
->prev
))->window
;
6062 XWINDOW (w
->prev
)->next
= p
->window
;
6067 if (!NILP (w
->parent
))
6069 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6071 XWINDOW (w
->parent
)->vchild
= p
->window
;
6072 XWINDOW (w
->parent
)->hchild
= Qnil
;
6076 XWINDOW (w
->parent
)->hchild
= p
->window
;
6077 XWINDOW (w
->parent
)->vchild
= Qnil
;
6082 /* If we squirreled away the buffer in the window's height,
6084 if (BUFFERP (w
->total_lines
))
6085 w
->buffer
= w
->total_lines
;
6086 w
->left_col
= p
->left_col
;
6087 w
->top_line
= p
->top_line
;
6088 w
->total_cols
= p
->total_cols
;
6089 w
->total_lines
= p
->total_lines
;
6090 w
->hscroll
= p
->hscroll
;
6091 w
->min_hscroll
= p
->min_hscroll
;
6092 w
->display_table
= p
->display_table
;
6093 w
->orig_top_line
= p
->orig_top_line
;
6094 w
->orig_total_lines
= p
->orig_total_lines
;
6095 w
->left_margin_cols
= p
->left_margin_cols
;
6096 w
->right_margin_cols
= p
->right_margin_cols
;
6097 w
->left_fringe_width
= p
->left_fringe_width
;
6098 w
->right_fringe_width
= p
->right_fringe_width
;
6099 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6100 w
->scroll_bar_width
= p
->scroll_bar_width
;
6101 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6102 w
->dedicated
= p
->dedicated
;
6103 w
->resize_proportionally
= p
->resize_proportionally
;
6104 XSETFASTINT (w
->last_modified
, 0);
6105 XSETFASTINT (w
->last_overlay_modified
, 0);
6107 /* Reinstall the saved buffer and pointers into it. */
6108 if (NILP (p
->buffer
))
6109 w
->buffer
= p
->buffer
;
6112 if (!NILP (XBUFFER (p
->buffer
)->name
))
6113 /* If saved buffer is alive, install it. */
6115 w
->buffer
= p
->buffer
;
6116 w
->start_at_line_beg
= p
->start_at_line_beg
;
6117 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6118 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6119 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6120 p
->mark
, w
->buffer
);
6122 /* As documented in Fcurrent_window_configuration, don't
6123 restore the location of point in the buffer which was
6124 current when the window configuration was recorded. */
6125 if (!EQ (p
->buffer
, new_current_buffer
)
6126 && XBUFFER (p
->buffer
) == current_buffer
)
6127 Fgoto_char (w
->pointm
);
6129 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6130 /* Else unless window has a live buffer, get one. */
6132 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6133 /* This will set the markers to beginning of visible
6135 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6136 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6137 w
->start_at_line_beg
= Qt
;
6140 /* Keeping window's old buffer; make sure the markers
6143 /* Set window markers at start of visible range. */
6144 if (XMARKER (w
->start
)->buffer
== 0)
6145 set_marker_restricted (w
->start
, make_number (0),
6147 if (XMARKER (w
->pointm
)->buffer
== 0)
6148 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6149 BUF_PT (XBUFFER (w
->buffer
)),
6150 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6151 w
->start_at_line_beg
= Qt
;
6156 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6157 /* Prevent "swapping out point" in the old selected window
6158 using the buffer that has been restored into it.
6159 We already swapped out point that from that window's old buffer. */
6160 selected_window
= Qnil
;
6162 /* Arrange *not* to restore point in the buffer that was
6163 current when the window configuration was saved. */
6164 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6165 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6166 make_number (old_point
),
6167 XWINDOW (data
->current_window
)->buffer
);
6169 Fselect_window (data
->current_window
, Qnil
);
6170 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6173 if (NILP (data
->focus_frame
)
6174 || (FRAMEP (data
->focus_frame
)
6175 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6176 Fredirect_frame_focus (frame
, data
->focus_frame
);
6178 #if 0 /* I don't understand why this is needed, and it causes problems
6179 when the frame's old selected window has been deleted. */
6180 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6181 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6185 /* Set the screen height to the value it had before this function. */
6186 if (previous_frame_lines
!= FRAME_LINES (f
)
6187 || previous_frame_cols
!= FRAME_COLS (f
))
6188 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6190 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6191 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6192 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6194 #ifdef HAVE_WINDOW_SYSTEM
6195 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6196 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6201 /* Now, free glyph matrices in windows that were not reused. */
6202 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6204 if (NILP (leaf_windows
[i
]->buffer
))
6206 /* Assert it's not reused as a combination. */
6207 xassert (NILP (leaf_windows
[i
]->hchild
)
6208 && NILP (leaf_windows
[i
]->vchild
));
6209 free_window_matrices (leaf_windows
[i
]);
6211 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6219 /* Fselect_window will have made f the selected frame, so we
6220 reselect the proper frame here. Fhandle_switch_frame will change the
6221 selected window too, but that doesn't make the call to
6222 Fselect_window above totally superfluous; it still sets f's
6224 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6225 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
6227 run_window_configuration_change_hook (f
);
6230 if (!NILP (new_current_buffer
))
6231 Fset_buffer (new_current_buffer
);
6233 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6234 minibuf_selected_window
= data
->minibuf_selected_window
;
6236 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6239 /* Mark all windows now on frame as deleted
6240 by setting their buffers to nil. */
6243 delete_all_subwindows (register struct window
*w
)
6245 if (!NILP (w
->next
))
6246 delete_all_subwindows (XWINDOW (w
->next
));
6247 if (!NILP (w
->vchild
))
6248 delete_all_subwindows (XWINDOW (w
->vchild
));
6249 if (!NILP (w
->hchild
))
6250 delete_all_subwindows (XWINDOW (w
->hchild
));
6252 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6254 if (!NILP (w
->buffer
))
6257 /* We set all three of these fields to nil, to make sure that we can
6258 distinguish this dead window from any live window. Live leaf
6259 windows will have buffer set, and combination windows will have
6260 vchild or hchild set. */
6265 Vwindow_list
= Qnil
;
6269 count_windows (register struct window
*window
)
6271 register int count
= 1;
6272 if (!NILP (window
->next
))
6273 count
+= count_windows (XWINDOW (window
->next
));
6274 if (!NILP (window
->vchild
))
6275 count
+= count_windows (XWINDOW (window
->vchild
));
6276 if (!NILP (window
->hchild
))
6277 count
+= count_windows (XWINDOW (window
->hchild
));
6282 /* Fill vector FLAT with leaf windows under W, starting at index I.
6283 Value is last index + 1. */
6286 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
6290 if (!NILP (w
->hchild
))
6291 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6292 else if (!NILP (w
->vchild
))
6293 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6297 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6304 /* Return a pointer to the glyph W's physical cursor is on. Value is
6305 null if W's current matrix is invalid, so that no meaningfull glyph
6309 get_phys_cursor_glyph (struct window
*w
)
6311 struct glyph_row
*row
;
6312 struct glyph
*glyph
;
6314 if (w
->phys_cursor
.vpos
>= 0
6315 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6316 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6318 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6319 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6328 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6330 register struct saved_window
*p
;
6331 register struct window
*w
;
6332 register Lisp_Object tem
;
6334 for (;!NILP (window
); window
= w
->next
)
6336 p
= SAVED_WINDOW_N (vector
, i
);
6337 w
= XWINDOW (window
);
6339 XSETFASTINT (w
->temslot
, i
); i
++;
6341 p
->buffer
= w
->buffer
;
6342 p
->left_col
= w
->left_col
;
6343 p
->top_line
= w
->top_line
;
6344 p
->total_cols
= w
->total_cols
;
6345 p
->total_lines
= w
->total_lines
;
6346 p
->hscroll
= w
->hscroll
;
6347 p
->min_hscroll
= w
->min_hscroll
;
6348 p
->display_table
= w
->display_table
;
6349 p
->orig_top_line
= w
->orig_top_line
;
6350 p
->orig_total_lines
= w
->orig_total_lines
;
6351 p
->left_margin_cols
= w
->left_margin_cols
;
6352 p
->right_margin_cols
= w
->right_margin_cols
;
6353 p
->left_fringe_width
= w
->left_fringe_width
;
6354 p
->right_fringe_width
= w
->right_fringe_width
;
6355 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6356 p
->scroll_bar_width
= w
->scroll_bar_width
;
6357 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6358 p
->dedicated
= w
->dedicated
;
6359 p
->resize_proportionally
= w
->resize_proportionally
;
6360 if (!NILP (w
->buffer
))
6362 /* Save w's value of point in the window configuration.
6363 If w is the selected window, then get the value of point
6364 from the buffer; pointm is garbage in the selected window. */
6365 if (EQ (window
, selected_window
))
6367 p
->pointm
= Fmake_marker ();
6368 set_marker_both (p
->pointm
, w
->buffer
,
6369 BUF_PT (XBUFFER (w
->buffer
)),
6370 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6373 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6375 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6376 p
->start_at_line_beg
= w
->start_at_line_beg
;
6378 tem
= XBUFFER (w
->buffer
)->mark
;
6379 p
->mark
= Fcopy_marker (tem
, Qnil
);
6386 p
->start_at_line_beg
= Qnil
;
6389 if (NILP (w
->parent
))
6392 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6397 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6399 if (!NILP (w
->vchild
))
6400 i
= save_window_save (w
->vchild
, vector
, i
);
6401 if (!NILP (w
->hchild
))
6402 i
= save_window_save (w
->hchild
, vector
, i
);
6408 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6409 Scurrent_window_configuration
, 0, 1, 0,
6410 doc
: /* Return an object representing the current window configuration of FRAME.
6411 If FRAME is nil or omitted, use the selected frame.
6412 This describes the number of windows, their sizes and current buffers,
6413 and for each displayed buffer, where display starts, and the positions of
6414 point and mark. An exception is made for point in the current buffer:
6415 its value is -not- saved.
6416 This also records the currently selected frame, and FRAME's focus
6417 redirection (see `redirect-frame-focus'). */)
6420 register Lisp_Object tem
;
6421 register int n_windows
;
6422 register struct save_window_data
*data
;
6427 frame
= selected_frame
;
6428 CHECK_LIVE_FRAME (frame
);
6431 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6432 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6433 PVEC_WINDOW_CONFIGURATION
);
6435 data
->frame_cols
= FRAME_COLS (f
);
6436 data
->frame_lines
= FRAME_LINES (f
);
6437 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6438 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6439 data
->selected_frame
= selected_frame
;
6440 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6441 XSETBUFFER (data
->current_buffer
, current_buffer
);
6442 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6443 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6444 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6445 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6446 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6447 data
->saved_windows
= tem
;
6448 for (i
= 0; i
< n_windows
; i
++)
6449 XVECTOR (tem
)->contents
[i
]
6450 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6451 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6452 XSETWINDOW_CONFIGURATION (tem
, data
);
6456 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6458 doc
: /* Execute BODY, preserving window sizes and contents.
6459 Return the value of the last form in BODY.
6460 Restore which buffer appears in which window, where display starts,
6461 and the value of point and mark for each window.
6462 Also restore the choice of selected window.
6463 Also restore which buffer is current.
6464 Does not restore the value of point in current buffer.
6465 usage: (save-window-excursion BODY...) */)
6468 register Lisp_Object val
;
6469 register int count
= SPECPDL_INDEX ();
6471 record_unwind_protect (Fset_window_configuration
,
6472 Fcurrent_window_configuration (Qnil
));
6473 val
= Fprogn (args
);
6474 return unbind_to (count
, val
);
6479 /***********************************************************************
6481 ***********************************************************************/
6484 window_tree (struct window
*w
)
6486 Lisp_Object tail
= Qnil
;
6487 Lisp_Object result
= Qnil
;
6494 if (!NILP (w
->hchild
))
6495 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6496 window_tree (XWINDOW (w
->hchild
))));
6497 else if (!NILP (w
->vchild
))
6498 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6499 window_tree (XWINDOW (w
->vchild
))));
6503 result
= tail
= Fcons (wn
, Qnil
);
6507 XSETCDR (tail
, Fcons (wn
, Qnil
));
6511 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6519 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6521 doc
: /* Return the window tree for frame FRAME.
6523 The return value is a list of the form (ROOT MINI), where ROOT
6524 represents the window tree of the frame's root window, and MINI
6525 is the frame's minibuffer window.
6527 If the root window is not split, ROOT is the root window itself.
6528 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6529 horizontal split, and t for a vertical split, EDGES gives the combined
6530 size and position of the subwindows in the split, and the rest of the
6531 elements are the subwindows in the split. Each of the subwindows may
6532 again be a window or a list representing a window split, and so on.
6533 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6535 If FRAME is nil or omitted, return information on the currently
6542 frame
= selected_frame
;
6544 CHECK_FRAME (frame
);
6547 if (!FRAME_LIVE_P (f
))
6550 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6554 /***********************************************************************
6556 ***********************************************************************/
6558 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6560 doc
: /* Set width of marginal areas of window WINDOW.
6561 If WINDOW is nil, set margins of the currently selected window.
6562 Second arg LEFT-WIDTH specifies the number of character cells to
6563 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6564 does the same for the right marginal area. A nil width parameter
6565 means no margin. */)
6566 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6568 struct window
*w
= decode_window (window
);
6570 /* Translate negative or zero widths to nil.
6571 Margins that are too wide have to be checked elsewhere. */
6573 if (!NILP (left_width
))
6575 CHECK_NUMBER (left_width
);
6576 if (XINT (left_width
) <= 0)
6580 if (!NILP (right_width
))
6582 CHECK_NUMBER (right_width
);
6583 if (XINT (right_width
) <= 0)
6587 if (!EQ (w
->left_margin_cols
, left_width
)
6588 || !EQ (w
->right_margin_cols
, right_width
))
6590 w
->left_margin_cols
= left_width
;
6591 w
->right_margin_cols
= right_width
;
6593 adjust_window_margins (w
);
6595 ++windows_or_buffers_changed
;
6596 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6603 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6605 doc
: /* Get width of marginal areas of window WINDOW.
6606 If WINDOW is omitted or nil, use the currently selected window.
6607 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6608 If a marginal area does not exist, its width will be returned
6610 (Lisp_Object window
)
6612 struct window
*w
= decode_window (window
);
6613 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6618 /***********************************************************************
6620 ***********************************************************************/
6622 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6624 doc
: /* Set the fringe widths of window WINDOW.
6625 If WINDOW is nil, set the fringe widths of the currently selected
6627 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6628 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6629 fringe width. If a fringe width arg is nil, that means to use the
6630 frame's default fringe width. Default fringe widths can be set with
6631 the command `set-fringe-style'.
6632 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6633 outside of the display margins. By default, fringes are drawn between
6634 display marginal areas and the text area. */)
6635 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6637 struct window
*w
= decode_window (window
);
6639 if (!NILP (left_width
))
6640 CHECK_NATNUM (left_width
);
6641 if (!NILP (right_width
))
6642 CHECK_NATNUM (right_width
);
6644 /* Do nothing on a tty. */
6645 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6646 && (!EQ (w
->left_fringe_width
, left_width
)
6647 || !EQ (w
->right_fringe_width
, right_width
)
6648 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6650 w
->left_fringe_width
= left_width
;
6651 w
->right_fringe_width
= right_width
;
6652 w
->fringes_outside_margins
= outside_margins
;
6654 adjust_window_margins (w
);
6656 clear_glyph_matrix (w
->current_matrix
);
6657 w
->window_end_valid
= Qnil
;
6659 ++windows_or_buffers_changed
;
6660 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6667 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6669 doc
: /* Get width of fringes of window WINDOW.
6670 If WINDOW is omitted or nil, use the currently selected window.
6671 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6672 (Lisp_Object window
)
6674 struct window
*w
= decode_window (window
);
6676 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6677 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6678 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6679 ? Qt
: Qnil
), Qnil
)));
6684 /***********************************************************************
6686 ***********************************************************************/
6688 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6690 doc
: /* Set width and type of scroll bars of window WINDOW.
6691 If window is nil, set scroll bars of the currently selected window.
6692 Second parameter WIDTH specifies the pixel width for the scroll bar;
6693 this is automatically adjusted to a multiple of the frame column width.
6694 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6695 bar: left, right, or nil.
6696 If WIDTH is nil, use the frame's scroll-bar width.
6697 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6698 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6699 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6701 struct window
*w
= decode_window (window
);
6705 CHECK_NATNUM (width
);
6707 if (XINT (width
) == 0)
6708 vertical_type
= Qnil
;
6711 if (!(NILP (vertical_type
)
6712 || EQ (vertical_type
, Qleft
)
6713 || EQ (vertical_type
, Qright
)
6714 || EQ (vertical_type
, Qt
)))
6715 error ("Invalid type of vertical scroll bar");
6717 if (!EQ (w
->scroll_bar_width
, width
)
6718 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6720 w
->scroll_bar_width
= width
;
6721 w
->vertical_scroll_bar_type
= vertical_type
;
6723 adjust_window_margins (w
);
6725 clear_glyph_matrix (w
->current_matrix
);
6726 w
->window_end_valid
= Qnil
;
6728 ++windows_or_buffers_changed
;
6729 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6736 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6738 doc
: /* Get width and type of scroll bars of window WINDOW.
6739 If WINDOW is omitted or nil, use the currently selected window.
6740 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6741 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6743 (Lisp_Object window
)
6745 struct window
*w
= decode_window (window
);
6746 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6747 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6748 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6749 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6750 Fcons (w
->vertical_scroll_bar_type
,
6751 Fcons (Qnil
, Qnil
))));
6756 /***********************************************************************
6758 ***********************************************************************/
6760 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6761 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6762 Use the selected window if WINDOW is nil or omitted.
6763 Normally, value is a multiple of the canonical character height of WINDOW;
6764 optional second arg PIXELS-P means value is measured in pixels. */)
6765 (Lisp_Object window
, Lisp_Object pixels_p
)
6772 window
= selected_window
;
6774 CHECK_WINDOW (window
);
6775 w
= XWINDOW (window
);
6776 f
= XFRAME (w
->frame
);
6778 if (FRAME_WINDOW_P (f
))
6779 result
= (NILP (pixels_p
)
6780 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6781 : make_number (-w
->vscroll
));
6783 result
= make_number (0);
6788 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6790 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6791 WINDOW nil means use the selected window. Normally, VSCROLL is a
6792 non-negative multiple of the canonical character height of WINDOW;
6793 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6794 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6795 corresponds to an integral number of pixels. The return value is the
6796 result of this rounding.
6797 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6798 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6804 window
= selected_window
;
6806 CHECK_WINDOW (window
);
6807 CHECK_NUMBER_OR_FLOAT (vscroll
);
6809 w
= XWINDOW (window
);
6810 f
= XFRAME (w
->frame
);
6812 if (FRAME_WINDOW_P (f
))
6814 int old_dy
= w
->vscroll
;
6816 w
->vscroll
= - (NILP (pixels_p
)
6817 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6818 : XFLOATINT (vscroll
));
6819 w
->vscroll
= min (w
->vscroll
, 0);
6821 if (w
->vscroll
!= old_dy
)
6823 /* Adjust glyph matrix of the frame if the virtual display
6824 area becomes larger than before. */
6825 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6828 /* Prevent redisplay shortcuts. */
6829 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6833 return Fwindow_vscroll (window
, pixels_p
);
6837 /* Call FN for all leaf windows on frame F. FN is called with the
6838 first argument being a pointer to the leaf window, and with
6839 additional argument USER_DATA. Stops when FN returns 0. */
6842 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *), void *user_data
)
6844 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6845 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6846 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6850 /* Helper function for foreach_window. Call FN for all leaf windows
6851 reachable from W. FN is called with the first argument being a
6852 pointer to the leaf window, and with additional argument USER_DATA.
6853 Stop when FN returns 0. Value is 0 if stopped by FN. */
6856 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6860 for (cont
= 1; w
&& cont
;)
6862 if (!NILP (w
->hchild
))
6863 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6864 else if (!NILP (w
->vchild
))
6865 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6867 cont
= fn (w
, user_data
);
6869 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6876 /* Freeze or unfreeze the window start of W unless it is a
6877 mini-window or the selected window. FREEZE_P non-null means freeze
6878 the window start. */
6881 freeze_window_start (struct window
*w
, void *freeze_p
)
6883 if (MINI_WINDOW_P (w
)
6884 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6885 && (w
== XWINDOW (selected_window
)
6886 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6887 && ! NILP (Vminibuf_scroll_window
)
6888 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6891 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6896 /* Freeze or unfreeze the window starts of all leaf windows on frame
6897 F, except the selected window and a mini-window. FREEZE_P non-zero
6898 means freeze the window start. */
6901 freeze_window_starts (struct frame
*f
, int freeze_p
)
6903 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6907 /***********************************************************************
6909 ***********************************************************************/
6911 /* Return 1 if window configurations C1 and C2
6912 describe the same state of affairs. This is used by Fequal. */
6915 compare_window_configurations (Lisp_Object c1
, Lisp_Object c2
, int ignore_positions
)
6917 register struct save_window_data
*d1
, *d2
;
6918 struct Lisp_Vector
*sw1
, *sw2
;
6921 CHECK_WINDOW_CONFIGURATION (c1
);
6922 CHECK_WINDOW_CONFIGURATION (c2
);
6924 d1
= (struct save_window_data
*) XVECTOR (c1
);
6925 d2
= (struct save_window_data
*) XVECTOR (c2
);
6926 sw1
= XVECTOR (d1
->saved_windows
);
6927 sw2
= XVECTOR (d2
->saved_windows
);
6929 if (d1
->frame_cols
!= d2
->frame_cols
)
6931 if (d1
->frame_lines
!= d2
->frame_lines
)
6933 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
6935 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6937 /* Don't compare the current_window field directly.
6938 Instead see w1_is_current and w2_is_current, below. */
6939 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6941 if (! ignore_positions
)
6943 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6945 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6948 /* Don't compare the root_window field.
6949 We don't require the two configurations
6950 to use the same window object,
6951 and the two root windows must be equivalent
6952 if everything else compares equal. */
6953 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6956 /* Verify that the two confis have the same number of windows. */
6957 if (sw1
->size
!= sw2
->size
)
6960 for (i
= 0; i
< sw1
->size
; i
++)
6962 struct saved_window
*p1
, *p2
;
6963 int w1_is_current
, w2_is_current
;
6965 p1
= SAVED_WINDOW_N (sw1
, i
);
6966 p2
= SAVED_WINDOW_N (sw2
, i
);
6968 /* Verify that the current windows in the two
6969 configurations correspond to each other. */
6970 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6971 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6973 if (w1_is_current
!= w2_is_current
)
6976 /* Verify that the corresponding windows do match. */
6977 if (! EQ (p1
->buffer
, p2
->buffer
))
6979 if (! EQ (p1
->left_col
, p2
->left_col
))
6981 if (! EQ (p1
->top_line
, p2
->top_line
))
6983 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6985 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6987 if (! EQ (p1
->display_table
, p2
->display_table
))
6989 if (! EQ (p1
->parent
, p2
->parent
))
6991 if (! EQ (p1
->prev
, p2
->prev
))
6993 if (! ignore_positions
)
6995 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6997 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6999 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7001 if (NILP (Fequal (p1
->start
, p2
->start
)))
7003 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7005 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7008 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7010 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7012 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7014 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7016 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7018 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7020 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7027 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7028 Scompare_window_configurations
, 2, 2, 0,
7029 doc
: /* Compare two window configurations as regards the structure of windows.
7030 This function ignores details such as the values of point and mark
7031 and scrolling positions. */)
7032 (Lisp_Object x
, Lisp_Object y
)
7034 if (compare_window_configurations (x
, y
, 1))
7040 init_window_once (void)
7042 struct frame
*f
= make_initial_frame ();
7043 XSETFRAME (selected_frame
, f
);
7044 Vterminal_frame
= selected_frame
;
7045 minibuf_window
= f
->minibuffer_window
;
7046 selected_window
= f
->selected_window
;
7047 last_nonminibuf_frame
= f
;
7049 window_initialized
= 1;
7055 Vwindow_list
= Qnil
;
7059 syms_of_window (void)
7061 Qscroll_up
= intern_c_string ("scroll-up");
7062 staticpro (&Qscroll_up
);
7064 Qscroll_down
= intern_c_string ("scroll-down");
7065 staticpro (&Qscroll_down
);
7067 Qscroll_command
= intern_c_string ("scroll-command");
7068 staticpro (&Qscroll_command
);
7070 Fput (Qscroll_up
, Qscroll_command
, Qt
);
7071 Fput (Qscroll_down
, Qscroll_command
, Qt
);
7073 Qwindow_size_fixed
= intern_c_string ("window-size-fixed");
7074 staticpro (&Qwindow_size_fixed
);
7075 Fset (Qwindow_size_fixed
, Qnil
);
7077 staticpro (&Qwindow_configuration_change_hook
);
7078 Qwindow_configuration_change_hook
7079 = intern_c_string ("window-configuration-change-hook");
7081 Qwindowp
= intern_c_string ("windowp");
7082 staticpro (&Qwindowp
);
7084 Qwindow_configuration_p
= intern_c_string ("window-configuration-p");
7085 staticpro (&Qwindow_configuration_p
);
7087 Qwindow_live_p
= intern_c_string ("window-live-p");
7088 staticpro (&Qwindow_live_p
);
7090 Qdisplay_buffer
= intern_c_string ("display-buffer");
7091 staticpro (&Qdisplay_buffer
);
7093 Qtemp_buffer_show_hook
= intern_c_string ("temp-buffer-show-hook");
7094 staticpro (&Qtemp_buffer_show_hook
);
7096 staticpro (&Vwindow_list
);
7098 minibuf_selected_window
= Qnil
;
7099 staticpro (&minibuf_selected_window
);
7101 window_scroll_pixel_based_preserve_x
= -1;
7102 window_scroll_pixel_based_preserve_y
= -1;
7103 window_scroll_preserve_hpos
= -1;
7104 window_scroll_preserve_vpos
= -1;
7106 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7107 doc
: /* Non-nil means call as function to display a help buffer.
7108 The function is called with one argument, the buffer to be displayed.
7109 Used by `with-output-to-temp-buffer'.
7110 If this function is used, then it must do the entire job of showing
7111 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7112 Vtemp_buffer_show_function
= Qnil
;
7114 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7115 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7116 Vminibuf_scroll_window
= Qnil
;
7118 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7119 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7120 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7121 is displayed in the `mode-line' face. */);
7122 mode_line_in_non_selected_windows
= 1;
7124 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7125 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7126 Vother_window_scroll_buffer
= Qnil
;
7128 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7129 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7130 auto_window_vscroll_p
= 1;
7132 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7133 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7134 next_screen_context_lines
= 2;
7136 DEFVAR_INT ("window-min-height", &window_min_height
,
7137 doc
: /* Allow deleting windows less than this tall.
7138 The value is measured in line units. If a window wants a modeline it
7139 is counted as one line.
7141 Emacs honors settings of this variable when enlarging or shrinking
7142 windows vertically. A value less than 1 is invalid. */);
7143 window_min_height
= 4;
7145 DEFVAR_INT ("window-min-width", &window_min_width
,
7146 doc
: /* Allow deleting windows less than this wide.
7147 The value is measured in characters and includes any fringes or
7150 Emacs honors settings of this variable when enlarging or shrinking
7151 windows horizontally. A value less than 2 is invalid. */);
7152 window_min_width
= 10;
7154 DEFVAR_LISP ("scroll-preserve-screen-position",
7155 &Vscroll_preserve_screen_position
,
7156 doc
: /* *Controls if scroll commands move point to keep its screen position unchanged.
7157 A value of nil means point does not keep its screen position except
7158 at the scroll margin or window boundary respectively.
7159 A value of t means point keeps its screen position if the scroll
7160 command moved it vertically out of the window, e.g. when scrolling
7162 Any other value means point always keeps its screen position.
7163 Scroll commands should have the `scroll-command' property
7164 on their symbols to be controlled by this variable. */);
7165 Vscroll_preserve_screen_position
= Qnil
;
7167 DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type
,
7168 doc
: /* Type of marker to use for `window-point'. */);
7169 Vwindow_point_insertion_type
= Qnil
;
7171 DEFVAR_LISP ("window-configuration-change-hook",
7172 &Vwindow_configuration_change_hook
,
7173 doc
: /* Functions to call when window configuration changes.
7174 The buffer-local part is run once per window, with the relevant window
7175 selected; while the global part is run only once for the modified frame,
7176 with the relevant frame selected. */);
7177 Vwindow_configuration_change_hook
= Qnil
;
7179 DEFVAR_LISP ("recenter-redisplay", &Vrecenter_redisplay
,
7180 doc
: /* If non-nil, then the `recenter' command with a nil argument
7181 will redraw the entire frame; the special value `tty' causes the
7182 frame to be redrawn only if it is a tty frame. */);
7183 Vrecenter_redisplay
= Qtty
;
7186 defsubr (&Sselected_window
);
7187 defsubr (&Sminibuffer_window
);
7188 defsubr (&Swindow_minibuffer_p
);
7189 defsubr (&Swindowp
);
7190 defsubr (&Swindow_live_p
);
7191 defsubr (&Spos_visible_in_window_p
);
7192 defsubr (&Swindow_line_height
);
7193 defsubr (&Swindow_buffer
);
7194 defsubr (&Swindow_height
);
7195 defsubr (&Swindow_width
);
7196 defsubr (&Swindow_full_width_p
);
7197 defsubr (&Swindow_hscroll
);
7198 defsubr (&Sset_window_hscroll
);
7199 defsubr (&Swindow_redisplay_end_trigger
);
7200 defsubr (&Sset_window_redisplay_end_trigger
);
7201 defsubr (&Swindow_edges
);
7202 defsubr (&Swindow_pixel_edges
);
7203 defsubr (&Swindow_absolute_pixel_edges
);
7204 defsubr (&Swindow_inside_edges
);
7205 defsubr (&Swindow_inside_pixel_edges
);
7206 defsubr (&Swindow_inside_absolute_pixel_edges
);
7207 defsubr (&Scoordinates_in_window_p
);
7208 defsubr (&Swindow_at
);
7209 defsubr (&Swindow_point
);
7210 defsubr (&Swindow_start
);
7211 defsubr (&Swindow_end
);
7212 defsubr (&Sset_window_point
);
7213 defsubr (&Sset_window_start
);
7214 defsubr (&Swindow_dedicated_p
);
7215 defsubr (&Sset_window_dedicated_p
);
7216 defsubr (&Swindow_display_table
);
7217 defsubr (&Sset_window_display_table
);
7218 defsubr (&Snext_window
);
7219 defsubr (&Sprevious_window
);
7220 defsubr (&Sother_window
);
7221 defsubr (&Sget_lru_window
);
7222 defsubr (&Sget_largest_window
);
7223 defsubr (&Sget_buffer_window
);
7224 defsubr (&Sdelete_other_windows
);
7225 defsubr (&Sdelete_windows_on
);
7226 defsubr (&Sreplace_buffer_in_windows
);
7227 defsubr (&Sdelete_window
);
7228 defsubr (&Sset_window_buffer
);
7229 defsubr (&Sselect_window
);
7230 defsubr (&Sforce_window_update
);
7231 defsubr (&Ssplit_window
);
7232 defsubr (&Senlarge_window
);
7233 defsubr (&Sshrink_window
);
7234 defsubr (&Sadjust_window_trailing_edge
);
7235 defsubr (&Sscroll_up
);
7236 defsubr (&Sscroll_down
);
7237 defsubr (&Sscroll_left
);
7238 defsubr (&Sscroll_right
);
7239 defsubr (&Sother_window_for_scrolling
);
7240 defsubr (&Sscroll_other_window
);
7241 defsubr (&Sminibuffer_selected_window
);
7242 defsubr (&Srecenter
);
7243 defsubr (&Swindow_text_height
);
7244 defsubr (&Smove_to_window_line
);
7245 defsubr (&Swindow_configuration_p
);
7246 defsubr (&Swindow_configuration_frame
);
7247 defsubr (&Sset_window_configuration
);
7248 defsubr (&Scurrent_window_configuration
);
7249 defsubr (&Ssave_window_excursion
);
7250 defsubr (&Swindow_tree
);
7251 defsubr (&Sset_window_margins
);
7252 defsubr (&Swindow_margins
);
7253 defsubr (&Sset_window_fringes
);
7254 defsubr (&Swindow_fringes
);
7255 defsubr (&Sset_window_scroll_bars
);
7256 defsubr (&Swindow_scroll_bars
);
7257 defsubr (&Swindow_vscroll
);
7258 defsubr (&Sset_window_vscroll
);
7259 defsubr (&Scompare_window_configurations
);
7260 defsubr (&Swindow_list
);
7261 defsubr (&Swindow_parameters
);
7262 defsubr (&Swindow_parameter
);
7263 defsubr (&Sset_window_parameter
);
7268 keys_of_window (void)
7270 initial_define_key (control_x_map
, '1', "delete-other-windows");
7271 initial_define_key (control_x_map
, '2', "split-window");
7272 initial_define_key (control_x_map
, '0', "delete-window");
7273 initial_define_key (control_x_map
, 'o', "other-window");
7274 initial_define_key (control_x_map
, '^', "enlarge-window");
7275 initial_define_key (control_x_map
, '<', "scroll-left");
7276 initial_define_key (control_x_map
, '>', "scroll-right");
7278 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
7279 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7280 initial_define_key (meta_map
, 'v', "scroll-down-command");
7283 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7284 (do not change this comment) */