1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2011
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
35 #include "dispextern.h"
36 #include "blockinput.h"
37 #include "intervals.h"
38 #include "termhooks.h" /* For FRAME_TERMINAL. */
42 #endif /* HAVE_X_WINDOWS */
53 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
54 Lisp_Object Qdisplay_buffer
;
55 Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
56 Lisp_Object Qwindow_size_fixed
;
58 static int displayed_window_lines (struct window
*);
59 static struct window
*decode_window (Lisp_Object
);
60 static int count_windows (struct window
*);
61 static int get_leaf_windows (struct window
*, struct window
**, int);
62 static void window_scroll (Lisp_Object
, int, int, int);
63 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
64 static void window_scroll_line_based (Lisp_Object
, int, int, int);
65 static int window_min_size_1 (struct window
*, int, int);
66 static int window_min_size_2 (struct window
*, int, int);
67 static int window_min_size (struct window
*, int, int, int, int *);
68 static void size_window (Lisp_Object
, int, int, int, int, int);
69 static int freeze_window_start (struct window
*, void *);
70 static int window_fixed_size_p (struct window
*, int, int);
71 static void enlarge_window (Lisp_Object
, int, int);
72 static Lisp_Object
window_list (void);
73 static int add_window_to_list (struct window
*, void *);
74 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
80 static void foreach_window (struct frame
*,
81 int (* fn
) (struct window
*, void *),
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
);
87 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
89 /* This is the window in which the terminal's cursor should
90 be left when nothing is being done with it. This must
91 always be a leaf window, and its buffer is selected by
92 the top level editing loop at the end of each command.
94 This value is always the same as
95 FRAME_SELECTED_WINDOW (selected_frame). */
97 Lisp_Object selected_window
;
99 /* A list of all windows for use by next_window and Fwindow_list.
100 Functions creating or deleting windows should invalidate this cache
101 by setting it to nil. */
103 Lisp_Object Vwindow_list
;
105 /* The mini-buffer window of the selected frame.
106 Note that you cannot test for mini-bufferness of an arbitrary window
107 by comparing against this; but you can test for mini-bufferness of
108 the selected window. */
110 Lisp_Object minibuf_window
;
112 /* Non-nil means it is the window whose mode line should be
113 shown as the selected window when the minibuffer is selected. */
115 Lisp_Object minibuf_selected_window
;
117 /* Hook run at end of temp_output_buffer_show. */
119 Lisp_Object Qtemp_buffer_show_hook
;
121 /* Incremented for each window created. */
123 static int sequence_number
;
125 /* Nonzero after init_window_once has finished. */
127 static int window_initialized
;
129 /* Hook to run when window config changes. */
131 static Lisp_Object Qwindow_configuration_change_hook
;
132 /* Incremented by 1 whenever a window is deleted. */
134 int window_deletion_count
;
136 /* Used by the function window_scroll_pixel_based */
138 static int window_scroll_pixel_based_preserve_x
;
139 static int window_scroll_pixel_based_preserve_y
;
141 /* Same for window_scroll_line_based. */
143 static int window_scroll_preserve_hpos
;
144 static int window_scroll_preserve_vpos
;
146 #if 0 /* This isn't used anywhere. */
147 /* Nonzero means we can split a frame even if it is "unsplittable". */
148 static int inhibit_frame_unsplittable
;
152 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
153 doc
: /* Return t if OBJECT is a window. */)
156 return WINDOWP (object
) ? Qt
: Qnil
;
159 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
160 doc
: /* Return t if OBJECT is a window which is currently visible. */)
163 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
170 register struct window
*p
;
172 p
= allocate_window ();
174 XSETFASTINT (p
->sequence_number
, sequence_number
);
175 XSETFASTINT (p
->left_col
, 0);
176 XSETFASTINT (p
->top_line
, 0);
177 XSETFASTINT (p
->total_lines
, 0);
178 XSETFASTINT (p
->total_cols
, 0);
179 XSETFASTINT (p
->hscroll
, 0);
180 XSETFASTINT (p
->min_hscroll
, 0);
181 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
182 p
->start
= Fmake_marker ();
183 p
->pointm
= Fmake_marker ();
184 XSETFASTINT (p
->use_time
, 0);
186 p
->display_table
= Qnil
;
188 p
->window_parameters
= Qnil
;
189 p
->pseudo_window_p
= 0;
190 memset (&p
->cursor
, 0, sizeof (p
->cursor
));
191 memset (&p
->last_cursor
, 0, sizeof (p
->last_cursor
));
192 memset (&p
->phys_cursor
, 0, sizeof (p
->phys_cursor
));
193 p
->desired_matrix
= p
->current_matrix
= 0;
194 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
195 p
->phys_cursor_type
= -1;
196 p
->phys_cursor_width
= -1;
197 p
->must_be_updated_p
= 0;
198 XSETFASTINT (p
->window_end_vpos
, 0);
199 XSETFASTINT (p
->window_end_pos
, 0);
200 p
->window_end_valid
= Qnil
;
203 XSETFASTINT (p
->last_point
, 0);
204 p
->frozen_window_start_p
= 0;
205 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
206 p
->left_margin_cols
= Qnil
;
207 p
->right_margin_cols
= Qnil
;
208 p
->left_fringe_width
= Qnil
;
209 p
->right_fringe_width
= Qnil
;
210 p
->fringes_outside_margins
= Qnil
;
211 p
->scroll_bar_width
= Qnil
;
212 p
->vertical_scroll_bar_type
= Qt
;
213 p
->resize_proportionally
= Qnil
;
219 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
220 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
223 return selected_window
;
226 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
227 doc
: /* Return the window used now for minibuffers.
228 If the optional argument FRAME is specified, return the minibuffer window
229 used by that frame. */)
233 frame
= selected_frame
;
234 CHECK_LIVE_FRAME (frame
);
235 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
238 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
239 doc
: /* Return non-nil if WINDOW is a minibuffer window.
240 WINDOW defaults to the selected window. */)
243 struct window
*w
= decode_window (window
);
244 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
248 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
249 Spos_visible_in_window_p
, 0, 3, 0,
250 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
251 Return nil if that position is scrolled vertically out of view.
252 If a character is only partially visible, nil is returned, unless the
253 optional argument PARTIALLY is non-nil.
254 If POS is only out of view because of horizontal scrolling, return non-nil.
255 If POS is t, it specifies the position of the last visible glyph in WINDOW.
256 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
258 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
259 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
260 where X and Y are the pixel coordinates relative to the top left corner
261 of the window. The remaining elements are omitted if the character after
262 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
263 off-window at the top and bottom of the row, ROWH is the height of the
264 display row, and VPOS is the row number (0-based) containing POS. */)
265 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
267 register struct window
*w
;
268 register EMACS_INT posint
;
269 register struct buffer
*buf
;
271 Lisp_Object in_window
= Qnil
;
272 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
275 w
= decode_window (window
);
276 buf
= XBUFFER (w
->buffer
);
277 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
281 else if (!NILP (pos
))
283 CHECK_NUMBER_COERCE_MARKER (pos
);
286 else if (w
== XWINDOW (selected_window
))
289 posint
= XMARKER (w
->pointm
)->charpos
;
291 /* If position is above window start or outside buffer boundaries,
292 or if window start is out of range, position is not visible. */
294 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
295 && CHARPOS (top
) >= BUF_BEGV (buf
)
296 && CHARPOS (top
) <= BUF_ZV (buf
)
297 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
298 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
301 if (!NILP (in_window
) && !NILP (partially
))
303 Lisp_Object part
= Qnil
;
305 part
= list4 (make_number (rtop
), make_number (rbot
),
306 make_number (rowh
), make_number (vpos
));
307 in_window
= Fcons (make_number (x
),
308 Fcons (make_number (y
), part
));
314 DEFUN ("window-line-height", Fwindow_line_height
,
315 Swindow_line_height
, 0, 2, 0,
316 doc
: /* Return height in pixels of text line LINE in window WINDOW.
317 If WINDOW is nil or omitted, use selected window.
319 Return height of current line if LINE is omitted or nil. Return height of
320 header or mode line if LINE is `header-line' and `mode-line'.
321 Otherwise, LINE is a text line number starting from 0. A negative number
322 counts from the end of the window.
324 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
325 in pixels of the visible part of the line, VPOS and YPOS are the
326 vertical position in lines and pixels of the line, relative to the top
327 of the first text line, and OFFBOT is the number of off-window pixels at
328 the bottom of the text line. If there are off-window pixels at the top
329 of the (first) text line, YPOS is negative.
331 Return nil if window display is not up-to-date. In that case, use
332 `pos-visible-in-window-p' to obtain the information. */)
333 (Lisp_Object line
, Lisp_Object window
)
335 register struct window
*w
;
336 register struct buffer
*b
;
337 struct glyph_row
*row
, *end_row
;
338 int max_y
, crop
, i
, n
;
340 w
= decode_window (window
);
343 || w
->pseudo_window_p
)
346 CHECK_BUFFER (w
->buffer
);
347 b
= XBUFFER (w
->buffer
);
349 /* Fail if current matrix is not up-to-date. */
350 if (NILP (w
->window_end_valid
)
351 || current_buffer
->clip_changed
352 || current_buffer
->prevent_redisplay_optimizations_p
353 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
354 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
360 if (i
< 0 || i
>= w
->current_matrix
->nrows
361 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
363 max_y
= window_text_bottom_y (w
);
367 if (EQ (line
, Qheader_line
))
369 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
371 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
374 return list4 (make_number (row
->height
),
375 make_number (0), make_number (0),
379 if (EQ (line
, Qmode_line
))
381 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
384 return list4 (make_number (row
->height
),
385 make_number (0), /* not accurate */
386 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
387 + window_text_bottom_y (w
)),
394 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
395 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
396 max_y
= window_text_bottom_y (w
);
399 while ((n
< 0 || i
< n
)
400 && row
<= end_row
&& row
->enabled_p
401 && row
->y
+ row
->height
< max_y
)
404 if (row
> end_row
|| !row
->enabled_p
)
416 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
417 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
419 make_number (row
->y
),
425 static struct window
*
426 decode_window (register Lisp_Object window
)
429 return XWINDOW (selected_window
);
431 CHECK_LIVE_WINDOW (window
);
432 return XWINDOW (window
);
435 static struct window
*
436 decode_any_window (register Lisp_Object window
)
439 return XWINDOW (selected_window
);
441 CHECK_WINDOW (window
);
442 return XWINDOW (window
);
445 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
446 doc
: /* Return the buffer that WINDOW is displaying.
447 WINDOW defaults to the selected window. */)
450 return decode_window (window
)->buffer
;
453 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
454 doc
: /* Return the number of lines in WINDOW.
455 WINDOW defaults to the selected window.
457 The return value includes WINDOW's mode line and header line, if any.
459 Note: The function does not take into account the value of `line-spacing'
460 when calculating the number of lines in WINDOW. */)
463 return decode_any_window (window
)->total_lines
;
466 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
467 doc
: /* Return the number of display columns in WINDOW.
468 WINDOW defaults to the selected window.
470 Note: The return value is the number of columns available for text in
471 WINDOW. If you want to find out how many columns WINDOW takes up, use
472 (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
475 return make_number (window_box_text_cols (decode_any_window (window
)));
478 DEFUN ("window-full-width-p", Fwindow_full_width_p
, Swindow_full_width_p
, 0, 1, 0,
479 doc
: /* Return t if WINDOW is as wide as its frame.
480 WINDOW defaults to the selected window. */)
483 return WINDOW_FULL_WIDTH_P (decode_any_window (window
)) ? Qt
: Qnil
;
486 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
487 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
488 WINDOW defaults to the selected window. */)
491 return decode_window (window
)->hscroll
;
494 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
495 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
496 Return NCOL. NCOL should be zero or positive.
498 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
499 window so that the location of point moves off-window. */)
500 (Lisp_Object window
, Lisp_Object ncol
)
502 struct window
*w
= decode_window (window
);
506 hscroll
= max (0, XINT (ncol
));
508 /* Prevent redisplay shortcuts when changing the hscroll. */
509 if (XINT (w
->hscroll
) != hscroll
)
510 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
512 w
->hscroll
= make_number (hscroll
);
516 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
517 Swindow_redisplay_end_trigger
, 0, 1, 0,
518 doc
: /* Return WINDOW's redisplay end trigger value.
519 WINDOW defaults to the selected window.
520 See `set-window-redisplay-end-trigger' for more information. */)
523 return decode_window (window
)->redisplay_end_trigger
;
526 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
527 Sset_window_redisplay_end_trigger
, 2, 2, 0,
528 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
529 VALUE should be a buffer position (typically a marker) or nil.
530 If it is a buffer position, then if redisplay in WINDOW reaches a position
531 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
532 with two arguments: WINDOW, and the end trigger value.
533 Afterwards the end-trigger value is reset to nil. */)
534 (register Lisp_Object window
, Lisp_Object value
)
536 register struct window
*w
;
538 w
= decode_window (window
);
539 w
->redisplay_end_trigger
= value
;
543 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
544 doc
: /* Return a list of the edge coordinates of WINDOW.
545 The list has the form (LEFT TOP RIGHT BOTTOM).
546 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
547 all relative to 0, 0 at top left corner of frame.
549 RIGHT is one more than the rightmost column occupied by WINDOW.
550 BOTTOM is one more than the bottommost row occupied by WINDOW.
551 The edges include the space used by WINDOW's scroll bar, display
552 margins, fringes, header line, and/or mode line. For the edges of
553 just the text area, use `window-inside-edges'. */)
556 register struct window
*w
= decode_any_window (window
);
558 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
559 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
560 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
561 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
565 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
566 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
567 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
568 the top left corner of the frame.
570 RIGHT is one more than the rightmost x position occupied by WINDOW.
571 BOTTOM is one more than the bottommost y position occupied by WINDOW.
572 The pixel edges include the space used by WINDOW's scroll bar, display
573 margins, fringes, header line, and/or mode line. For the pixel edges
574 of just the text area, use `window-inside-pixel-edges'. */)
577 register struct window
*w
= decode_any_window (window
);
579 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
580 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
581 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
582 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
587 calc_absolute_offset(struct window
*w
, int *add_x
, int *add_y
)
589 struct frame
*f
= XFRAME (w
->frame
);
591 #ifdef FRAME_MENUBAR_HEIGHT
592 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
594 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
595 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
596 #elif FRAME_TOOLBAR_HEIGHT
597 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
599 #ifdef FRAME_NS_TITLEBAR_HEIGHT
600 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
602 *add_x
= f
->left_pos
;
603 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
604 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
608 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
609 Swindow_absolute_pixel_edges
, 0, 1, 0,
610 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
611 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
612 the top left corner of the display.
614 RIGHT is one more than the rightmost x position occupied by WINDOW.
615 BOTTOM is one more than the bottommost y position occupied by WINDOW.
616 The pixel edges include the space used by WINDOW's scroll bar, display
617 margins, fringes, header line, and/or mode line. For the pixel edges
618 of just the text area, use `window-inside-absolute-pixel-edges'. */)
621 register struct window
*w
= decode_any_window (window
);
623 calc_absolute_offset (w
, &add_x
, &add_y
);
625 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
626 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
627 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
628 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
632 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
633 doc
: /* Return a list of the edge coordinates of WINDOW.
634 The list has the form (LEFT TOP RIGHT BOTTOM).
635 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
636 all relative to 0, 0 at top left corner of frame.
638 RIGHT is one more than the rightmost column of WINDOW's text area.
639 BOTTOM is one more than the bottommost row of WINDOW's text area.
640 The inside edges do not include the space used by the WINDOW's scroll
641 bar, display margins, fringes, header line, and/or mode line. */)
644 register struct window
*w
= decode_any_window (window
);
646 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
647 + WINDOW_LEFT_MARGIN_COLS (w
)
648 + WINDOW_LEFT_FRINGE_COLS (w
)),
649 make_number (WINDOW_TOP_EDGE_LINE (w
)
650 + WINDOW_HEADER_LINE_LINES (w
)),
651 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
652 - WINDOW_RIGHT_MARGIN_COLS (w
)
653 - WINDOW_RIGHT_FRINGE_COLS (w
)),
654 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
655 - WINDOW_MODE_LINE_LINES (w
)));
658 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
659 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
660 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
661 the top left corner of the frame.
663 RIGHT is one more than the rightmost x position of WINDOW's text area.
664 BOTTOM is one more than the bottommost y position of WINDOW's text area.
665 The inside edges do not include the space used by WINDOW's scroll bar,
666 display margins, fringes, header line, and/or mode line. */)
669 register struct window
*w
= decode_any_window (window
);
671 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
672 + WINDOW_LEFT_MARGIN_WIDTH (w
)
673 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
674 make_number (WINDOW_TOP_EDGE_Y (w
)
675 + WINDOW_HEADER_LINE_HEIGHT (w
)),
676 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
677 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
678 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
679 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
680 - WINDOW_MODE_LINE_HEIGHT (w
)));
683 DEFUN ("window-inside-absolute-pixel-edges",
684 Fwindow_inside_absolute_pixel_edges
,
685 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
686 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
687 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
688 the top left corner of the display.
690 RIGHT is one more than the rightmost x position of WINDOW's text area.
691 BOTTOM is one more than the bottommost y position of WINDOW's text area.
692 The inside edges do not include the space used by WINDOW's scroll bar,
693 display margins, fringes, header line, and/or mode line. */)
696 register struct window
*w
= decode_any_window (window
);
698 calc_absolute_offset (w
, &add_x
, &add_y
);
700 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
701 + WINDOW_LEFT_MARGIN_WIDTH (w
)
702 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
703 make_number (WINDOW_TOP_EDGE_Y (w
)
704 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
705 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
706 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
707 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
708 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
709 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
712 /* Test if the character at column X, row Y is within window W.
713 If it is not, return ON_NOTHING;
714 if it is in the window's text area, return ON_TEXT;
715 if it is on the window's modeline, return ON_MODE_LINE;
716 if it is on the border between the window and its right sibling,
717 return ON_VERTICAL_BORDER.
718 if it is on a scroll bar, return ON_SCROLL_BAR.
719 if it is on the window's top line, return ON_HEADER_LINE;
720 if it is in left or right fringe of the window,
721 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
722 if it is in the marginal area to the left/right of the window,
723 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
725 X and Y are frame relative pixel coordinates. */
727 static enum window_part
728 coordinates_in_window (register struct window
*w
, int x
, int y
)
730 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
732 enum window_part part
;
733 int ux
= FRAME_COLUMN_WIDTH (f
);
734 int x0
= WINDOW_LEFT_EDGE_X (w
);
735 int x1
= WINDOW_RIGHT_EDGE_X (w
);
736 /* The width of the area where the vertical line can be dragged.
737 (Between mode lines for instance. */
738 int grabbable_width
= ux
;
739 int lmargin_width
, rmargin_width
, text_left
, text_right
;
740 int top_y
= WINDOW_TOP_EDGE_Y (w
);
741 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
743 /* Outside any interesting row? */
744 if (y
< top_y
|| y
>= bottom_y
)
747 /* In what's below, we subtract 1 when computing right_x because we
748 want the rightmost pixel, which is given by left_pixel+width-1. */
749 if (w
->pseudo_window_p
)
752 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
756 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
757 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
760 /* On the mode line or header line? If it's near the start of
761 the mode or header line of window that's has a horizontal
762 sibling, say it's on the vertical line. That's to be able
763 to resize windows horizontally in case we're using toolkit
766 if (WINDOW_WANTS_MODELINE_P (w
)
767 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
771 header_vertical_border_check
:
772 /* We're somewhere on the mode line. We consider the place
773 between mode lines of horizontally adjacent mode lines
774 as the vertical border. If scroll bars on the left,
775 return the right window. */
776 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
777 || WINDOW_RIGHTMOST_P (w
))
778 && !WINDOW_LEFTMOST_P (w
)
779 && eabs (x
- x0
) < grabbable_width
)
780 return ON_VERTICAL_BORDER
;
782 /* Make sure we're not at the rightmost position of a
783 mode-/header-line and there's yet another window on the
785 else if ((WINDOW_RIGHTMOST_P (w
) || x
< x1
)
786 && eabs (x
- x1
) < grabbable_width
)
787 return ON_VERTICAL_BORDER
;
789 if (x
< x0
|| x
>= x1
)
795 if (WINDOW_WANTS_HEADER_LINE_P (w
)
796 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
798 part
= ON_HEADER_LINE
;
799 goto header_vertical_border_check
;
802 if (x
< x0
|| x
>= x1
) return ON_NOTHING
;
804 /* Outside any interesting column? */
805 if (x
< left_x
|| x
> right_x
)
806 return ON_SCROLL_BAR
;
808 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
809 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
811 text_left
= window_box_left (w
, TEXT_AREA
);
812 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
814 if (FRAME_WINDOW_P (f
))
816 if (!w
->pseudo_window_p
817 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
818 && !WINDOW_RIGHTMOST_P (w
)
819 && (eabs (x
- right_x
) < grabbable_width
))
820 return ON_VERTICAL_BORDER
;
822 /* Need to say "x > right_x" rather than >=, since on character
823 terminals, the vertical line's x coordinate is right_x. */
824 else if (!w
->pseudo_window_p
825 && !WINDOW_RIGHTMOST_P (w
)
827 return ON_VERTICAL_BORDER
;
831 if (lmargin_width
> 0
832 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
833 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
834 : (x
< left_x
+ lmargin_width
)))
835 return ON_LEFT_MARGIN
;
837 return ON_LEFT_FRINGE
;
842 if (rmargin_width
> 0
843 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
844 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
845 : (x
>= right_x
- rmargin_width
)))
846 return ON_RIGHT_MARGIN
;
848 return ON_RIGHT_FRINGE
;
851 /* Everything special ruled out - must be on text area */
855 /* Take X is the frame-relative pixel x-coordinate, and return the
856 x-coordinate relative to part PART of window W. */
858 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
860 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
865 return x
- window_box_left (w
, TEXT_AREA
);
870 case ON_RIGHT_FRINGE
:
871 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
875 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
876 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
878 case ON_RIGHT_MARGIN
:
880 - ((w
->pseudo_window_p
)
881 ? WINDOW_TOTAL_WIDTH (w
)
882 : WINDOW_BOX_RIGHT_EDGE_X (w
))
883 + window_box_width (w
, RIGHT_MARGIN_AREA
)
884 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
885 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
888 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
893 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
894 Scoordinates_in_window_p
, 2, 2, 0,
895 doc
: /* Return non-nil if COORDINATES are in WINDOW.
896 COORDINATES is a cons of the form (X . Y), X and Y being distances
897 measured in characters from the upper-left corner of the frame.
898 \(0 . 0) denotes the character in the upper left corner of the
900 If COORDINATES are in the text portion of WINDOW,
901 the coordinates relative to the window are returned.
902 If they are in the mode line of WINDOW, `mode-line' is returned.
903 If they are in the top mode line of WINDOW, `header-line' is returned.
904 If they are in the left fringe of WINDOW, `left-fringe' is returned.
905 If they are in the right fringe of WINDOW, `right-fringe' is returned.
906 If they are on the border between WINDOW and its right sibling,
907 `vertical-line' is returned.
908 If they are in the windows's left or right marginal areas, `left-margin'\n\
909 or `right-margin' is returned. */)
910 (register Lisp_Object coordinates
, Lisp_Object window
)
917 CHECK_WINDOW (window
);
918 w
= XWINDOW (window
);
919 f
= XFRAME (w
->frame
);
920 CHECK_CONS (coordinates
);
921 lx
= Fcar (coordinates
);
922 ly
= Fcdr (coordinates
);
923 CHECK_NUMBER_OR_FLOAT (lx
);
924 CHECK_NUMBER_OR_FLOAT (ly
);
925 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
926 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
928 switch (coordinates_in_window (w
, x
, y
))
934 /* Convert X and Y to window relative pixel coordinates, and
935 return the canonical char units. */
936 x
-= window_box_left (w
, TEXT_AREA
);
937 y
-= WINDOW_TOP_EDGE_Y (w
);
938 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
939 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
944 case ON_VERTICAL_BORDER
:
945 return Qvertical_line
;
953 case ON_RIGHT_FRINGE
:
954 return Qright_fringe
;
959 case ON_RIGHT_MARGIN
:
960 return Qright_margin
;
963 /* Historically we are supposed to return nil in this case. */
972 /* Callback for foreach_window, used in window_from_coordinates.
973 Check if window W contains coordinates specified by USER_DATA which
974 is actually a pointer to a struct check_window_data CW.
976 Check if window W contains coordinates *CW->x and *CW->y. If it
977 does, return W in *CW->window, as Lisp_Object, and return in
978 *CW->part the part of the window under coordinates *X,*Y. Return
979 zero from this function to stop iterating over windows. */
981 struct check_window_data
985 enum window_part
*part
;
989 check_window_containing (struct window
*w
, void *user_data
)
991 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
992 enum window_part found
;
995 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
996 if (found
!= ON_NOTHING
)
999 XSETWINDOW (*cw
->window
, w
);
1007 /* Find the window containing frame-relative pixel position X/Y and
1008 return it as a Lisp_Object.
1010 If X, Y is on one of the window's special `window_part' elements,
1011 set *PART to the id of that element.
1013 If there is no window under X, Y return nil and leave *PART
1014 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1016 This function was previously implemented with a loop cycling over
1017 windows with Fnext_window, and starting with the frame's selected
1018 window. It turned out that this doesn't work with an
1019 implementation of next_window using Vwindow_list, because
1020 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1021 tree of F when this function is called asynchronously from
1022 note_mouse_highlight. The original loop didn't terminate in this
1026 window_from_coordinates (struct frame
*f
, int x
, int y
,
1027 enum window_part
*part
, int tool_bar_p
)
1030 struct check_window_data cw
;
1031 enum window_part dummy
;
1037 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1038 foreach_window (f
, check_window_containing
, &cw
);
1040 /* If not found above, see if it's in the tool bar window, if a tool
1044 && WINDOWP (f
->tool_bar_window
)
1045 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1046 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1050 window
= f
->tool_bar_window
;
1056 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1057 doc
: /* Return window containing coordinates X and Y on FRAME.
1058 If omitted, FRAME defaults to the currently selected frame.
1059 The top left corner of the frame is considered to be row 0,
1061 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1066 frame
= selected_frame
;
1067 CHECK_LIVE_FRAME (frame
);
1070 /* Check that arguments are integers or floats. */
1071 CHECK_NUMBER_OR_FLOAT (x
);
1072 CHECK_NUMBER_OR_FLOAT (y
);
1074 return window_from_coordinates (f
,
1075 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1076 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1077 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1078 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1082 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1083 doc
: /* Return current value of point in WINDOW.
1084 WINDOW defaults to the selected window.
1086 For a nonselected window, this is the value point would have
1087 if that window were selected.
1089 Note that, when WINDOW is the selected window and its buffer
1090 is also currently selected, the value returned is the same as (point).
1091 It would be more strictly correct to return the `top-level' value
1092 of point, outside of any save-excursion forms.
1093 But that is hard to define. */)
1094 (Lisp_Object window
)
1096 register struct window
*w
= decode_window (window
);
1098 if (w
== XWINDOW (selected_window
)
1099 && current_buffer
== XBUFFER (w
->buffer
))
1101 return Fmarker_position (w
->pointm
);
1104 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1105 doc
: /* Return position at which display currently starts in WINDOW.
1106 WINDOW defaults to the selected window.
1107 This is updated by redisplay or by calling `set-window-start'. */)
1108 (Lisp_Object window
)
1110 return Fmarker_position (decode_window (window
)->start
);
1113 /* This is text temporarily removed from the doc string below.
1115 This function returns nil if the position is not currently known.
1116 That happens when redisplay is preempted and doesn't finish.
1117 If in that case you want to compute where the end of the window would
1118 have been if redisplay had finished, do this:
1120 (goto-char (window-start window))
1121 (vertical-motion (1- (window-height window)) window)
1124 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1125 doc
: /* Return position at which display currently ends in WINDOW.
1126 WINDOW defaults to the selected window.
1127 This is updated by redisplay, when it runs to completion.
1128 Simply changing the buffer text or setting `window-start'
1129 does not update this value.
1130 Return nil if there is no recorded value. \(This can happen if the
1131 last redisplay of WINDOW was preempted, and did not finish.)
1132 If UPDATE is non-nil, compute the up-to-date position
1133 if it isn't already recorded. */)
1134 (Lisp_Object window
, Lisp_Object update
)
1137 struct window
*w
= decode_window (window
);
1145 #if 0 /* This change broke some things. We should make it later. */
1146 /* If we don't know the end position, return nil.
1147 The user can compute it with vertical-motion if he wants to.
1148 It would be nicer to do it automatically,
1149 but that's so slow that it would probably bother people. */
1150 if (NILP (w
->window_end_valid
))
1155 && ! (! NILP (w
->window_end_valid
)
1156 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1157 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1160 struct text_pos startp
;
1162 struct buffer
*old_buffer
= NULL
;
1164 /* Cannot use Fvertical_motion because that function doesn't
1165 cope with variable-height lines. */
1166 if (b
!= current_buffer
)
1168 old_buffer
= current_buffer
;
1169 set_buffer_internal (b
);
1172 /* In case W->start is out of the range, use something
1173 reasonable. This situation occurred when loading a file with
1174 `-l' containing a call to `rmail' with subsequent other
1175 commands. At the end, W->start happened to be BEG, while
1176 rmail had already narrowed the buffer. */
1177 if (XMARKER (w
->start
)->charpos
< BEGV
)
1178 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1179 else if (XMARKER (w
->start
)->charpos
> ZV
)
1180 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1182 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1184 start_display (&it
, w
, startp
);
1185 move_it_vertically (&it
, window_box_height (w
));
1186 if (it
.current_y
< it
.last_visible_y
)
1187 move_it_past_eol (&it
);
1188 value
= make_number (IT_CHARPOS (it
));
1191 set_buffer_internal (old_buffer
);
1194 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1199 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1200 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1202 (Lisp_Object window
, Lisp_Object pos
)
1204 register struct window
*w
= decode_window (window
);
1206 CHECK_NUMBER_COERCE_MARKER (pos
);
1207 if (w
== XWINDOW (selected_window
)
1208 && XBUFFER (w
->buffer
) == current_buffer
)
1211 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1213 /* We have to make sure that redisplay updates the window to show
1214 the new value of point. */
1215 if (!EQ (window
, selected_window
))
1216 ++windows_or_buffers_changed
;
1221 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1222 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1223 WINDOW defaults to the selected window. Return POS.
1224 Optional third arg NOFORCE non-nil inhibits next redisplay from
1225 overriding motion of point in order to display at this exact start. */)
1226 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1228 register struct window
*w
= decode_window (window
);
1230 CHECK_NUMBER_COERCE_MARKER (pos
);
1231 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1232 /* this is not right, but much easier than doing what is right. */
1233 w
->start_at_line_beg
= Qnil
;
1235 w
->force_start
= Qt
;
1236 w
->update_mode_line
= Qt
;
1237 XSETFASTINT (w
->last_modified
, 0);
1238 XSETFASTINT (w
->last_overlay_modified
, 0);
1239 if (!EQ (window
, selected_window
))
1240 windows_or_buffers_changed
++;
1246 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1248 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1249 More precisely, return the value assigned by the last call of
1250 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1251 never called with WINDOW as its argument, or the value set by that
1252 function was internally reset since its last call. WINDOW defaults to
1253 the selected window.
1255 When a window is dedicated to its buffer, `display-buffer' will refrain
1256 from displaying another buffer in it. `get-lru-window' and
1257 `get-largest-window' treat dedicated windows specially.
1258 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1259 `kill-buffer' can delete a dedicated window and the containing frame.
1261 Functions like `set-window-buffer' may change the buffer displayed by a
1262 window, unless that window is "strongly" dedicated to its buffer, that
1263 is the value returned by `window-dedicated-p' is t. */)
1264 (Lisp_Object window
)
1266 return decode_window (window
)->dedicated
;
1269 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1270 Sset_window_dedicated_p
, 2, 2, 0,
1271 doc
: /* Mark WINDOW as dedicated according to FLAG.
1272 WINDOW defaults to the selected window. FLAG non-nil means mark WINDOW
1273 as dedicated to its buffer. FLAG nil means mark WINDOW as non-dedicated.
1276 When a window is dedicated to its buffer, `display-buffer' will refrain
1277 from displaying another buffer in it. `get-lru-window' and
1278 `get-largest-window' treat dedicated windows specially.
1279 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1280 `kill-buffer' can delete a dedicated window and the containing
1283 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1284 its buffer. Functions like `set-window-buffer' may change the buffer
1285 displayed by a window, unless that window is strongly dedicated to its
1286 buffer. If and when `set-window-buffer' displays another buffer in a
1287 window, it also makes sure that the window is not marked as dedicated. */)
1288 (Lisp_Object window
, Lisp_Object flag
)
1290 register struct window
*w
= decode_window (window
);
1292 w
->dedicated
= flag
;
1293 return w
->dedicated
;
1297 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1299 doc
: /* Return the parameters of WINDOW and their values.
1300 WINDOW defaults to the selected window. The return value is a list of
1301 elements of the form (PARAMETER . VALUE). */)
1302 (Lisp_Object window
)
1304 return Fcopy_alist (decode_window (window
)->window_parameters
);
1307 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1309 doc
: /* Return WINDOW's value for PARAMETER.
1310 WINDOW defaults to the selected window. */)
1311 (Lisp_Object window
, Lisp_Object parameter
)
1315 result
= Fassq (parameter
, decode_window (window
)->window_parameters
);
1316 return CDR_SAFE (result
);
1319 DEFUN ("set-window-parameter", Fset_window_parameter
,
1320 Sset_window_parameter
, 3, 3, 0,
1321 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1322 WINDOW defaults to the selected window. Return VALUE. */)
1323 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1325 register struct window
*w
= decode_window (window
);
1326 Lisp_Object old_alist_elt
;
1328 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1329 if (NILP (old_alist_elt
))
1330 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1332 Fsetcdr (old_alist_elt
, value
);
1337 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1339 doc
: /* Return the display-table that WINDOW is using.
1340 WINDOW defaults to the selected window. */)
1341 (Lisp_Object window
)
1343 return decode_window (window
)->display_table
;
1346 /* Get the display table for use on window W. This is either W's
1347 display table or W's buffer's display table. Ignore the specified
1348 tables if they are not valid; if no valid table is specified,
1351 struct Lisp_Char_Table
*
1352 window_display_table (struct window
*w
)
1354 struct Lisp_Char_Table
*dp
= NULL
;
1356 if (DISP_TABLE_P (w
->display_table
))
1357 dp
= XCHAR_TABLE (w
->display_table
);
1358 else if (BUFFERP (w
->buffer
))
1360 struct buffer
*b
= XBUFFER (w
->buffer
);
1362 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1363 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1364 else if (DISP_TABLE_P (Vstandard_display_table
))
1365 dp
= XCHAR_TABLE (Vstandard_display_table
);
1371 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1372 doc
: /* Set WINDOW's display-table to TABLE. */)
1373 (register Lisp_Object window
, Lisp_Object table
)
1375 register struct window
*w
;
1377 w
= decode_window (window
);
1378 w
->display_table
= table
;
1382 static void delete_window (Lisp_Object
);
1384 /* Record info on buffer window w is displaying
1385 when it is about to cease to display that buffer. */
1387 unshow_buffer (register struct window
*w
)
1394 if (b
!= XMARKER (w
->pointm
)->buffer
)
1398 if (w
== XWINDOW (selected_window
)
1399 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1400 /* Do this except when the selected window's buffer
1401 is being removed from some other window. */
1403 /* last_window_start records the start position that this buffer
1404 had in the last window to be disconnected from it.
1405 Now that this statement is unconditional,
1406 it is possible for the buffer to be displayed in the
1407 selected window, while last_window_start reflects another
1408 window which was recently showing the same buffer.
1409 Some people might say that might be a good thing. Let's see. */
1410 b
->last_window_start
= marker_position (w
->start
);
1412 /* Point in the selected window's buffer
1413 is actually stored in that buffer, and the window's pointm isn't used.
1414 So don't clobber point in that buffer. */
1415 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1416 /* This line helps to fix Horsley's testbug.el bug. */
1417 && !(WINDOWP (BVAR (b
, last_selected_window
))
1418 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1419 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1420 temp_set_point_both (b
,
1421 clip_to_bounds (BUF_BEGV (b
),
1422 XMARKER (w
->pointm
)->charpos
,
1424 clip_to_bounds (BUF_BEGV_BYTE (b
),
1425 marker_byte_position (w
->pointm
),
1428 if (WINDOWP (BVAR (b
, last_selected_window
))
1429 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1430 BVAR (b
, last_selected_window
) = Qnil
;
1433 /* Put replacement into the window structure in place of old. */
1435 replace_window (Lisp_Object old
, Lisp_Object replacement
)
1437 register Lisp_Object tem
;
1438 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1440 /* If OLD is its frame's root_window, then replacement is the new
1441 root_window for that frame. */
1443 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1444 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1446 p
->left_col
= o
->left_col
;
1447 p
->top_line
= o
->top_line
;
1448 p
->total_cols
= o
->total_cols
;
1449 p
->total_lines
= o
->total_lines
;
1450 p
->desired_matrix
= p
->current_matrix
= 0;
1452 memset (&p
->cursor
, 0, sizeof (p
->cursor
));
1453 memset (&p
->last_cursor
, 0, sizeof (p
->last_cursor
));
1454 memset (&p
->phys_cursor
, 0, sizeof (p
->phys_cursor
));
1455 p
->phys_cursor_type
= -1;
1456 p
->phys_cursor_width
= -1;
1457 p
->must_be_updated_p
= 0;
1458 p
->pseudo_window_p
= 0;
1459 XSETFASTINT (p
->window_end_vpos
, 0);
1460 XSETFASTINT (p
->window_end_pos
, 0);
1461 p
->window_end_valid
= Qnil
;
1462 p
->frozen_window_start_p
= 0;
1463 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1465 p
->next
= tem
= o
->next
;
1467 XWINDOW (tem
)->prev
= replacement
;
1469 p
->prev
= tem
= o
->prev
;
1471 XWINDOW (tem
)->next
= replacement
;
1473 p
->parent
= tem
= o
->parent
;
1476 if (EQ (XWINDOW (tem
)->vchild
, old
))
1477 XWINDOW (tem
)->vchild
= replacement
;
1478 if (EQ (XWINDOW (tem
)->hchild
, old
))
1479 XWINDOW (tem
)->hchild
= replacement
;
1482 /*** Here, if replacement is a vertical combination
1483 and so is its new parent, we should make replacement's
1484 children be children of that parent instead. ***/
1487 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1488 doc
: /* Remove WINDOW from its frame.
1489 WINDOW defaults to the selected window. Return nil.
1490 Signal an error when WINDOW is the only window on its frame. */)
1491 (register Lisp_Object window
)
1495 window
= selected_window
;
1497 CHECK_LIVE_WINDOW (window
);
1499 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1500 delete_window (window
);
1502 run_window_configuration_change_hook (f
);
1508 delete_window (register Lisp_Object window
)
1510 register Lisp_Object tem
, parent
, sib
;
1511 register struct window
*p
;
1512 register struct window
*par
;
1515 /* Because this function is called by other C code on non-leaf
1516 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1517 so we can't decode_window here. */
1518 CHECK_WINDOW (window
);
1519 p
= XWINDOW (window
);
1521 /* It's a no-op to delete an already-deleted window. */
1522 if (NILP (p
->buffer
)
1524 && NILP (p
->vchild
))
1529 error ("Attempt to delete minibuffer or sole ordinary window");
1530 par
= XWINDOW (parent
);
1532 windows_or_buffers_changed
++;
1533 Vwindow_list
= Qnil
;
1534 f
= XFRAME (WINDOW_FRAME (p
));
1535 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1537 /* Are we trying to delete any frame's selected window? */
1539 Lisp_Object swindow
, pwindow
;
1541 /* See if the frame's selected window is either WINDOW
1542 or any subwindow of it, by finding all that window's parents
1543 and comparing each one with WINDOW. */
1544 swindow
= FRAME_SELECTED_WINDOW (f
);
1549 while (!NILP (pwindow
))
1551 if (EQ (window
, pwindow
))
1553 pwindow
= XWINDOW (pwindow
)->parent
;
1556 /* If the window being deleted is not a parent of SWINDOW,
1557 then SWINDOW is ok as the new selected window. */
1558 if (!EQ (window
, pwindow
))
1560 /* Otherwise, try another window for SWINDOW. */
1561 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);
1563 /* If we get back to the frame's selected window,
1564 it means there was no acceptable alternative,
1565 so we cannot delete. */
1566 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1567 error ("Cannot delete window");
1570 /* If we need to change SWINDOW, do it. */
1571 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1573 /* If we're about to delete the selected window on the
1574 selected frame, then we should use Fselect_window to select
1575 the new window. On the other hand, if we're about to
1576 delete the selected window on any other frame, we shouldn't do
1577 anything but set the frame's selected_window slot. */
1578 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1579 Fselect_window (swindow
, Qnil
);
1581 FRAME_SELECTED_WINDOW (f
) = swindow
;
1585 /* Now we know we can delete this one. */
1586 window_deletion_count
++;
1589 /* tem is null for dummy parent windows
1590 (which have inferiors but not any contents themselves) */
1594 unchain_marker (XMARKER (p
->pointm
));
1595 unchain_marker (XMARKER (p
->start
));
1598 /* Free window glyph matrices. It is sure that they are allocated
1599 again when ADJUST_GLYPHS is called. Block input so that expose
1600 events and other events that access glyph matrices are not
1601 processed while we are changing them. */
1603 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1607 XWINDOW (tem
)->prev
= p
->prev
;
1611 XWINDOW (tem
)->next
= p
->next
;
1613 if (EQ (window
, par
->hchild
))
1614 par
->hchild
= p
->next
;
1615 if (EQ (window
, par
->vchild
))
1616 par
->vchild
= p
->next
;
1618 /* Find one of our siblings to give our space to. */
1622 /* If p gives its space to its next sibling, that sibling needs
1623 to have its top/left side pulled back to where p's is.
1624 set_window_{height,width} will re-position the sibling's
1627 XWINDOW (sib
)->top_line
= p
->top_line
;
1628 XWINDOW (sib
)->left_col
= p
->left_col
;
1631 /* Stretch that sibling. */
1632 if (!NILP (par
->vchild
))
1633 set_window_height (sib
,
1634 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1636 if (!NILP (par
->hchild
))
1637 set_window_width (sib
,
1638 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1641 /* If parent now has only one child,
1642 put the child into the parent's place. */
1646 if (NILP (XWINDOW (tem
)->next
)) {
1647 replace_window (parent
, tem
);
1648 par
= XWINDOW (tem
);
1651 /* Since we may be deleting combination windows, we must make sure that
1652 not only p but all its children have been marked as deleted. */
1653 if (! NILP (p
->hchild
))
1654 delete_all_subwindows (XWINDOW (p
->hchild
));
1655 else if (! NILP (p
->vchild
))
1656 delete_all_subwindows (XWINDOW (p
->vchild
));
1658 /* Mark this window as deleted. */
1659 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1661 if (! NILP (par
->parent
))
1662 par
= XWINDOW (par
->parent
);
1664 /* Check if we have a v/hchild with a v/hchild. In that case remove
1667 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1669 p
= XWINDOW (par
->vchild
);
1670 par
->vchild
= p
->vchild
;
1673 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1675 p
= XWINDOW (par
->hchild
);
1676 par
->hchild
= p
->hchild
;
1684 while (! NILP (tem
)) {
1685 XWINDOW (tem
)->parent
= p
->parent
;
1686 if (NILP (XWINDOW (tem
)->next
))
1688 tem
= XWINDOW (tem
)->next
;
1691 /* The next of the v/hchild we are removing is now the next of the
1692 last child for the v/hchild:
1693 Before v/hchild -> v/hchild -> next1 -> next2
1696 After: v/hchild -> next1 -> next2 -> next3
1698 XWINDOW (tem
)->next
= p
->next
;
1699 if (! NILP (p
->next
))
1700 XWINDOW (p
->next
)->prev
= tem
;
1702 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1706 /* Adjust glyph matrices. */
1713 /***********************************************************************
1715 ***********************************************************************/
1717 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1718 pointer. This is a callback function for foreach_window, used in
1719 function window_list. */
1722 add_window_to_list (struct window
*w
, void *user_data
)
1724 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1726 XSETWINDOW (window
, w
);
1727 *list
= Fcons (window
, *list
);
1732 /* Return a list of all windows, for use by next_window. If
1733 Vwindow_list is a list, return that list. Otherwise, build a new
1734 list, cache it in Vwindow_list, and return that. */
1739 if (!CONSP (Vwindow_list
))
1743 Vwindow_list
= Qnil
;
1744 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1746 Lisp_Object args
[2];
1748 /* We are visiting windows in canonical order, and add
1749 new windows at the front of args[1], which means we
1750 have to reverse this list at the end. */
1752 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1753 args
[0] = Vwindow_list
;
1754 args
[1] = Fnreverse (args
[1]);
1755 Vwindow_list
= Fnconc (2, args
);
1759 return Vwindow_list
;
1763 /* Value is non-zero if WINDOW satisfies the constraints given by
1764 OWINDOW, MINIBUF and ALL_FRAMES.
1766 MINIBUF t means WINDOW may be minibuffer windows.
1767 `lambda' means WINDOW may not be a minibuffer window.
1768 a window means a specific minibuffer window
1770 ALL_FRAMES t means search all frames,
1771 nil means search just current frame,
1772 `visible' means search just visible frames on the
1774 0 means search visible and iconified frames on the
1776 a window means search the frame that window belongs to,
1777 a frame means consider windows on that frame, only. */
1780 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
1782 struct window
*w
= XWINDOW (window
);
1783 struct frame
*f
= XFRAME (w
->frame
);
1784 int candidate_p
= 1;
1786 if (!BUFFERP (w
->buffer
))
1788 else if (MINI_WINDOW_P (w
)
1789 && (EQ (minibuf
, Qlambda
)
1790 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1792 /* If MINIBUF is `lambda' don't consider any mini-windows.
1793 If it is a window, consider only that one. */
1796 else if (EQ (all_frames
, Qt
))
1798 else if (NILP (all_frames
))
1800 xassert (WINDOWP (owindow
));
1801 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1803 else if (EQ (all_frames
, Qvisible
))
1805 FRAME_SAMPLE_VISIBILITY (f
);
1806 candidate_p
= FRAME_VISIBLE_P (f
)
1807 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1808 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1811 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1813 FRAME_SAMPLE_VISIBILITY (f
);
1814 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
1815 #ifdef HAVE_X_WINDOWS
1816 /* Yuck!! If we've just created the frame and the
1817 window-manager requested the user to place it
1818 manually, the window may still not be considered
1819 `visible'. I'd argue it should be at least
1820 something like `iconified', but don't know how to do
1822 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
1823 && !f
->output_data
.x
->has_been_visible
)
1826 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1827 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1829 else if (WINDOWP (all_frames
))
1830 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1831 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1832 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1833 else if (FRAMEP (all_frames
))
1834 candidate_p
= EQ (all_frames
, w
->frame
);
1840 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1841 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
1842 MINIBUF, and ALL_FRAMES. */
1845 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
1848 *window
= selected_window
;
1850 CHECK_LIVE_WINDOW (*window
);
1852 /* MINIBUF nil may or may not include minibuffers. Decide if it
1854 if (NILP (*minibuf
))
1855 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1856 else if (!EQ (*minibuf
, Qt
))
1859 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1860 => count none of them, or a specific minibuffer window (the
1861 active one) to count. */
1863 /* ALL_FRAMES nil doesn't specify which frames to include. */
1864 if (NILP (*all_frames
))
1865 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1866 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1868 else if (EQ (*all_frames
, Qvisible
))
1870 else if (EQ (*all_frames
, make_number (0)))
1872 else if (FRAMEP (*all_frames
))
1874 else if (!EQ (*all_frames
, Qt
))
1879 /* Return the next or previous window of WINDOW in cyclic ordering
1880 of windows. NEXT_P non-zero means return the next window. See the
1881 documentation string of next-window for the meaning of MINIBUF and
1885 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
1887 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1889 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1890 return the first window on the frame. */
1891 if (FRAMEP (all_frames
)
1892 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1893 return Fframe_first_window (all_frames
);
1899 /* Find WINDOW in the list of all windows. */
1900 list
= Fmemq (window
, window_list ());
1902 /* Scan forward from WINDOW to the end of the window list. */
1904 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1905 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1908 /* Scan from the start of the window list up to WINDOW. */
1910 for (list
= Vwindow_list
;
1911 CONSP (list
) && !EQ (XCAR (list
), window
);
1913 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1917 window
= XCAR (list
);
1921 Lisp_Object candidate
, list
;
1923 /* Scan through the list of windows for candidates. If there are
1924 candidate windows in front of WINDOW, the last one of these
1925 is the one we want. If there are candidates following WINDOW
1926 in the list, again the last one of these is the one we want. */
1928 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1930 if (EQ (XCAR (list
), window
))
1932 if (WINDOWP (candidate
))
1935 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1937 candidate
= XCAR (list
);
1940 if (WINDOWP (candidate
))
1948 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1949 doc
: /* Return window following WINDOW in cyclic ordering of windows.
1950 WINDOW defaults to the selected window. The optional arguments
1951 MINIBUF and ALL-FRAMES specify the set of windows to consider.
1953 MINIBUF t means consider the minibuffer window even if the
1954 minibuffer is not active. MINIBUF nil or omitted means consider
1955 the minibuffer window only if the minibuffer is active. Any
1956 other value means do not consider the minibuffer window even if
1957 the minibuffer is active.
1959 Several frames may share a single minibuffer; if the minibuffer
1960 is active, all windows on all frames that share that minibuffer
1961 are considered too. Therefore, if you are using a separate
1962 minibuffer frame and the minibuffer is active and MINIBUF says it
1963 counts, `next-window' considers the windows in the frame from
1964 which you entered the minibuffer, as well as the minibuffer
1967 ALL-FRAMES nil or omitted means consider all windows on WINDOW's
1968 frame, plus the minibuffer window if specified by the MINIBUF
1969 argument, see above. If the minibuffer counts, consider all
1970 windows on all frames that share that minibuffer too.
1971 ALL-FRAMES t means consider all windows on all existing frames.
1972 ALL-FRAMES `visible' means consider all windows on all visible
1973 frames on the current terminal.
1974 ALL-FRAMES 0 means consider all windows on all visible and
1975 iconified frames on the current terminal.
1976 ALL-FRAMES a frame means consider all windows on that frame only.
1977 Anything else means consider all windows on WINDOW's frame and no
1980 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1981 `next-window' to iterate through the entire cycle of acceptable
1982 windows, eventually ending up back at the window you started with.
1983 `previous-window' traverses the same cycle, in the reverse order. */)
1984 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
1986 return next_window (window
, minibuf
, all_frames
, 1);
1990 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1991 doc
: /* Return window preceding WINDOW in cyclic ordering of windows.
1992 WINDOW defaults to the selected window. The optional arguments
1993 MINIBUF and ALL-FRAMES specify the set of windows to consider.
1994 For the precise meaning of these arguments see `next-window'.
1996 If you use consistent values for MINIBUF and ALL-FRAMES, you can
1997 use `previous-window' to iterate through the entire cycle of
1998 acceptable windows, eventually ending up back at the window you
1999 started with. `next-window' traverses the same cycle, in the
2001 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2003 return next_window (window
, minibuf
, all_frames
, 0);
2007 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
2008 doc
: /* Select another window in cyclic ordering of windows.
2009 COUNT specifies the number of windows to skip, starting with the
2010 selected window, before making the selection. If COUNT is
2011 positive, skip COUNT windows forwards. If COUNT is negative,
2012 skip -COUNT windows backwards. COUNT zero means do not skip any
2013 window, so select the selected window. In an interactive call,
2014 COUNT is the numeric prefix argument. Return nil.
2016 This function uses `next-window' for finding the window to select.
2017 The argument ALL-FRAMES has the same meaning as in `next-window',
2018 but the MINIBUF argument of `next-window' is always effectively
2020 (Lisp_Object count
, Lisp_Object all_frames
)
2025 CHECK_NUMBER (count
);
2026 window
= selected_window
;
2028 for (i
= XINT (count
); i
> 0; --i
)
2029 window
= Fnext_window (window
, Qnil
, all_frames
);
2031 window
= Fprevious_window (window
, Qnil
, all_frames
);
2033 Fselect_window (window
, Qnil
);
2038 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2039 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2040 FRAME nil or omitted means use the selected frame.
2041 WINDOW nil or omitted means use the selected window.
2042 MINIBUF t means include the minibuffer window, even if it isn't active.
2043 MINIBUF nil or omitted means include the minibuffer window only
2045 MINIBUF neither nil nor t means never include the minibuffer window. */)
2046 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2049 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2050 CHECK_WINDOW (window
);
2052 frame
= selected_frame
;
2054 if (!EQ (frame
, XWINDOW (window
)->frame
))
2055 error ("Window is on a different frame");
2057 return window_list_1 (window
, minibuf
, frame
);
2061 /* Return a list of windows in cyclic ordering. Arguments are like
2062 for `next-window'. */
2065 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2067 Lisp_Object tail
, list
, rest
;
2069 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2072 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2073 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2074 list
= Fcons (XCAR (tail
), list
);
2076 /* Rotate the list to start with WINDOW. */
2077 list
= Fnreverse (list
);
2078 rest
= Fmemq (window
, list
);
2079 if (!NILP (rest
) && !EQ (rest
, list
))
2081 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2083 XSETCDR (tail
, Qnil
);
2084 list
= nconc2 (rest
, list
);
2091 /* Look at all windows, performing an operation specified by TYPE
2093 If FRAMES is Qt, look at all frames;
2094 Qnil, look at just the selected frame;
2095 Qvisible, look at visible frames;
2096 a frame, just look at windows on that frame.
2097 If MINI is non-zero, perform the operation on minibuffer windows too. */
2102 GET_BUFFER_WINDOW
, /* Arg is buffer */
2103 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2104 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2105 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2107 UNSHOW_BUFFER
, /* Arg is buffer */
2108 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2113 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2115 Lisp_Object window
, windows
, best_window
, frame_arg
;
2117 struct gcpro gcpro1
;
2119 /* If we're only looping through windows on a particular frame,
2120 frame points to that frame. If we're looping through windows
2121 on all frames, frame is 0. */
2122 if (FRAMEP (frames
))
2123 f
= XFRAME (frames
);
2124 else if (NILP (frames
))
2125 f
= SELECTED_FRAME ();
2130 frame_arg
= Qlambda
;
2131 else if (EQ (frames
, make_number (0)))
2133 else if (EQ (frames
, Qvisible
))
2138 /* frame_arg is Qlambda to stick to one frame,
2139 Qvisible to consider all visible frames,
2142 /* Pick a window to start with. */
2146 window
= FRAME_SELECTED_WINDOW (f
);
2148 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2150 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2154 for (; CONSP (windows
); windows
= XCDR (windows
))
2158 window
= XCAR (windows
);
2159 w
= XWINDOW (window
);
2161 /* Note that we do not pay attention here to whether the frame
2162 is visible, since Fwindow_list skips non-visible frames if
2163 that is desired, under the control of frame_arg. */
2164 if (!MINI_WINDOW_P (w
)
2165 /* For UNSHOW_BUFFER, we must always consider all windows. */
2166 || type
== UNSHOW_BUFFER
2167 || (mini
&& minibuf_level
> 0))
2170 case GET_BUFFER_WINDOW
:
2171 if (EQ (w
->buffer
, obj
)
2172 /* Don't find any minibuffer window
2173 except the one that is currently in use. */
2174 && (MINI_WINDOW_P (w
)
2175 ? EQ (window
, minibuf_window
)
2178 if (NILP (best_window
))
2179 best_window
= window
;
2180 else if (EQ (window
, selected_window
))
2181 /* Prefer to return selected-window. */
2182 RETURN_UNGCPRO (window
);
2183 else if (EQ (Fwindow_frame (window
), selected_frame
))
2184 /* Prefer windows on the current frame. */
2185 best_window
= window
;
2189 case GET_LRU_WINDOW
:
2190 /* `obj' is an integer encoding a bitvector.
2191 `obj & 1' means consider only full-width windows.
2192 `obj & 2' means consider also dedicated windows. */
2193 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2194 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2195 /* Minibuffer windows are always ignored. */
2196 || MINI_WINDOW_P (w
))
2198 if (NILP (best_window
)
2199 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2200 > XFASTINT (w
->use_time
)))
2201 best_window
= window
;
2204 case DELETE_OTHER_WINDOWS
:
2205 if (!EQ (window
, obj
))
2206 Fdelete_window (window
);
2209 case DELETE_BUFFER_WINDOWS
:
2210 if (EQ (w
->buffer
, obj
))
2212 struct frame
*fr
= XFRAME (WINDOW_FRAME (w
));
2214 /* If this window is dedicated, and in a frame of its own,
2216 if (EQ (window
, FRAME_ROOT_WINDOW (fr
))
2217 && !NILP (w
->dedicated
)
2218 && other_visible_frames (fr
))
2220 /* Skip the other windows on this frame.
2221 There might be one, the minibuffer! */
2222 while (CONSP (XCDR (windows
))
2223 && EQ (XWINDOW (XCAR (windows
))->frame
,
2224 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2225 windows
= XCDR (windows
);
2227 /* Now we can safely delete the frame. */
2228 delete_frame (w
->frame
, Qnil
);
2230 else if (NILP (w
->parent
))
2232 /* If we're deleting the buffer displayed in the
2233 only window on the frame, find a new buffer to
2236 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2237 /* Reset dedicated state of window. */
2238 w
->dedicated
= Qnil
;
2239 Fset_window_buffer (window
, buffer
, Qnil
);
2240 if (EQ (window
, selected_window
))
2241 Fset_buffer (w
->buffer
);
2244 Fdelete_window (window
);
2248 case GET_LARGEST_WINDOW
:
2249 { /* nil `obj' means to ignore dedicated windows. */
2250 /* Ignore dedicated windows and minibuffers. */
2251 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2254 if (NILP (best_window
))
2255 best_window
= window
;
2258 struct window
*b
= XWINDOW (best_window
);
2259 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2260 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2261 best_window
= window
;
2267 if (EQ (w
->buffer
, obj
))
2270 struct frame
*fr
= XFRAME (w
->frame
);
2272 /* Find another buffer to show in this window. */
2273 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2275 /* If this window is dedicated, and in a frame of its own,
2277 if (EQ (window
, FRAME_ROOT_WINDOW (fr
))
2278 && !NILP (w
->dedicated
)
2279 && other_visible_frames (fr
))
2281 /* Skip the other windows on this frame.
2282 There might be one, the minibuffer! */
2283 while (CONSP (XCDR (windows
))
2284 && EQ (XWINDOW (XCAR (windows
))->frame
,
2285 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2286 windows
= XCDR (windows
);
2288 /* Now we can safely delete the frame. */
2289 delete_frame (w
->frame
, Qnil
);
2291 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2293 Lisp_Object window_to_delete
;
2294 XSETWINDOW (window_to_delete
, w
);
2295 /* If this window is dedicated and not the only window
2296 in its frame, then kill it. */
2297 Fdelete_window (window_to_delete
);
2301 /* Otherwise show a different buffer in the window. */
2302 w
->dedicated
= Qnil
;
2303 Fset_window_buffer (window
, buffer
, Qnil
);
2304 if (EQ (window
, selected_window
))
2305 Fset_buffer (w
->buffer
);
2310 case REDISPLAY_BUFFER_WINDOWS
:
2311 if (EQ (w
->buffer
, obj
))
2313 mark_window_display_accurate (window
, 0);
2314 w
->update_mode_line
= Qt
;
2315 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2316 ++update_mode_lines
;
2317 best_window
= window
;
2321 /* Check for a window that has a killed buffer. */
2322 case CHECK_ALL_WINDOWS
:
2323 if (! NILP (w
->buffer
)
2324 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2328 case WINDOW_LOOP_UNUSED
:
2337 /* Used for debugging. Abort if any window has a dead buffer. */
2340 check_all_windows (void)
2342 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2345 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
2346 doc
: /* Return WINDOW's use time.
2347 WINDOW defaults to the selected window. The window with the highest use
2348 time is the most recently selected one. The window with the lowest use
2349 time is the least recently selected one. */)
2350 (Lisp_Object window
)
2352 return decode_window (window
)->use_time
;
2355 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2356 doc
: /* Return the window least recently selected or used for display.
2357 \(LRU means Least Recently Used.)
2359 Return a full-width window if possible.
2360 A minibuffer window is never a candidate.
2361 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2362 so if all windows are dedicated, the value is nil.
2363 If optional argument FRAME is `visible', search all visible frames.
2364 If FRAME is 0, search all visible and iconified frames.
2365 If FRAME is t, search all frames.
2366 If FRAME is nil, search only the selected frame.
2367 If FRAME is a frame, search only that frame. */)
2368 (Lisp_Object frame
, Lisp_Object dedicated
)
2370 register Lisp_Object w
;
2371 /* First try for a window that is full-width */
2372 w
= window_loop (GET_LRU_WINDOW
,
2373 NILP (dedicated
) ? make_number (1) : make_number (3),
2375 if (!NILP (w
) && !EQ (w
, selected_window
))
2377 /* If none of them, try the rest */
2378 return window_loop (GET_LRU_WINDOW
,
2379 NILP (dedicated
) ? make_number (0) : make_number (2),
2383 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2384 doc
: /* Return the largest window in area.
2385 A minibuffer window is never a candidate.
2386 A dedicated window is never a candidate unless DEDICATED is non-nil,
2387 so if all windows are dedicated, the value is nil.
2388 If optional argument FRAME is `visible', search all visible frames.
2389 If FRAME is 0, search all visible and iconified frames.
2390 If FRAME is t, search all frames.
2391 If FRAME is nil, search only the selected frame.
2392 If FRAME is a frame, search only that frame. */)
2393 (Lisp_Object frame
, Lisp_Object dedicated
)
2395 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2399 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2400 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2401 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to the
2403 If optional argument FRAME is `visible', search all visible frames.
2404 If optional argument FRAME is 0, search all visible and iconified frames.
2405 If FRAME is t, search all frames.
2406 If FRAME is nil, search only the selected frame.
2407 If FRAME is a frame, search only that frame. */)
2408 (Lisp_Object buffer_or_name
, Lisp_Object frame
)
2412 if (NILP (buffer_or_name
))
2413 buffer
= Fcurrent_buffer ();
2415 buffer
= Fget_buffer (buffer_or_name
);
2417 if (BUFFERP (buffer
))
2418 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2423 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2425 doc
: /* Make WINDOW (or the selected window) fill its frame.
2426 Only the frame WINDOW is on is affected.
2427 This function tries to reduce display jumps by keeping the text
2428 previously visible in WINDOW in the same place on the frame. Doing this
2429 depends on the value of (window-start WINDOW), so if calling this
2430 function in a program gives strange scrolling, make sure the
2431 window-start value is reasonable when this function is called. */)
2432 (Lisp_Object window
)
2439 window
= selected_window
;
2441 CHECK_LIVE_WINDOW (window
);
2442 w
= XWINDOW (window
);
2444 startpos
= marker_position (w
->start
);
2445 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2447 if (MINI_WINDOW_P (w
) && top
> 0)
2448 error ("Can't expand minibuffer to full frame");
2450 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2452 /* Try to minimize scrolling, by setting the window start to the point
2453 will cause the text at the old window start to be at the same place
2454 on the frame. But don't try to do this if the window start is
2455 outside the visible portion (as might happen when the display is
2456 not current, due to typeahead). */
2457 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2459 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2460 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2462 struct position pos
;
2463 struct buffer
*obuf
= current_buffer
;
2465 Fset_buffer (w
->buffer
);
2466 /* This computation used to temporarily move point, but that can
2467 have unwanted side effects due to text properties. */
2468 pos
= *vmotion (startpos
, -top
, w
);
2470 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2471 w
->window_end_valid
= Qnil
;
2472 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2473 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2475 /* We need to do this, so that the window-scroll-functions
2477 w
->optional_new_start
= Qt
;
2479 set_buffer_internal (obuf
);
2485 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2486 0, 2, "bDelete windows on (buffer): ",
2487 doc
: /* Delete all windows showing BUFFER-OR-NAME.
2488 BUFFER-OR-NAME may be a buffer or the name of an existing buffer and
2489 defaults to the current buffer.
2491 Optional second argument FRAME controls which frames are affected.
2492 If optional argument FRAME is `visible', search all visible frames.
2493 If FRAME is 0, search all visible and iconified frames.
2494 If FRAME is nil, search all frames.
2495 If FRAME is t, search only the selected frame.
2496 If FRAME is a frame, search only that frame.
2497 When a window showing BUFFER-OR-NAME is dedicated and the only window of
2498 its frame, that frame is deleted when there are other frames left. */)
2499 (Lisp_Object buffer_or_name
, Lisp_Object frame
)
2503 /* FRAME uses t and nil to mean the opposite of what window_loop
2507 else if (EQ (frame
, Qt
))
2510 if (NILP (buffer_or_name
))
2511 buffer
= Fcurrent_buffer ();
2514 buffer
= Fget_buffer (buffer_or_name
);
2515 CHECK_BUFFER (buffer
);
2518 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2523 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2524 Sreplace_buffer_in_windows
,
2525 0, 1, "bReplace buffer in windows: ",
2526 doc
: /* Replace BUFFER-OR-NAME with some other buffer in all windows showing it.
2527 BUFFER-OR-NAME may be a buffer or the name of an existing buffer and
2528 defaults to the current buffer.
2530 When a window showing BUFFER-OR-NAME is dedicated that window is
2531 deleted. If that window is the only window on its frame, that frame is
2532 deleted too when there are other frames left. If there are no other
2533 frames left, some other buffer is displayed in that window. */)
2534 (Lisp_Object buffer_or_name
)
2538 if (NILP (buffer_or_name
))
2539 buffer
= Fcurrent_buffer ();
2542 buffer
= Fget_buffer (buffer_or_name
);
2543 CHECK_BUFFER (buffer
);
2546 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2551 /* Replace BUFFER with some other buffer in all windows
2552 of all frames, even those on other keyboards. */
2555 replace_buffer_in_all_windows (Lisp_Object buffer
)
2557 Lisp_Object tail
, frame
;
2559 /* A single call to window_loop won't do the job
2560 because it only considers frames on the current keyboard.
2561 So loop manually over frames, and handle each one. */
2562 FOR_EACH_FRAME (tail
, frame
)
2563 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2566 /* Set the height of WINDOW and all its inferiors. */
2568 /* The smallest acceptable dimensions for a window. Anything smaller
2569 might crash Emacs. */
2571 #define MIN_SAFE_WINDOW_WIDTH (2)
2572 #define MIN_SAFE_WINDOW_HEIGHT (1)
2574 /* For wp non-zero the total number of columns of window w. Otherwise
2575 the total number of lines of w. */
2577 #define WINDOW_TOTAL_SIZE(w, wp) \
2578 (wp ? WINDOW_TOTAL_COLS (w) : WINDOW_TOTAL_LINES (w))
2580 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2581 minimum allowable size. */
2584 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2586 /* For height, we have to see:
2587 how many windows the frame has at minimum (one or two),
2588 and whether it has a menu bar or other special stuff at the top. */
2590 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2591 ? MIN_SAFE_WINDOW_HEIGHT
2592 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2594 if (FRAME_TOP_MARGIN (frame
) > 0)
2595 min_height
+= FRAME_TOP_MARGIN (frame
);
2597 if (*rows
< min_height
)
2599 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2600 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2603 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2604 check if W's width can be changed, otherwise check W's height.
2605 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2606 siblings, too. If none of the siblings is resizable, WINDOW isn't
2610 window_fixed_size_p (struct window
*w
, int width_p
, int check_siblings_p
)
2615 if (!NILP (w
->hchild
))
2617 c
= XWINDOW (w
->hchild
);
2621 /* A horizontal combination is fixed-width if all of if its
2623 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2624 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2625 fixed_p
= c
== NULL
;
2629 /* A horizontal combination is fixed-height if one of if its
2631 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2632 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2633 fixed_p
= c
!= NULL
;
2636 else if (!NILP (w
->vchild
))
2638 c
= XWINDOW (w
->vchild
);
2642 /* A vertical combination is fixed-width if one of if its
2644 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2645 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2646 fixed_p
= c
!= NULL
;
2650 /* A vertical combination is fixed-height if all of if its
2652 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2653 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2654 fixed_p
= c
== NULL
;
2657 else if (BUFFERP (w
->buffer
))
2659 struct buffer
*old
= current_buffer
;
2662 current_buffer
= XBUFFER (w
->buffer
);
2663 val
= find_symbol_value (Qwindow_size_fixed
);
2664 current_buffer
= old
;
2667 if (!EQ (val
, Qunbound
))
2669 fixed_p
= !NILP (val
);
2672 && ((EQ (val
, Qheight
) && width_p
)
2673 || (EQ (val
, Qwidth
) && !width_p
)))
2677 /* Can't tell if this one is resizable without looking at
2678 siblings. If all siblings are fixed-size this one is too. */
2679 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2683 for (child
= w
->prev
; WINDOWP (child
); child
= XWINDOW (child
)->prev
)
2684 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2688 for (child
= w
->next
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
2689 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2702 /* Return minimum size of leaf window W. WIDTH_P non-zero means return
2703 the minimum width of W, WIDTH_P zero means return the minimum height
2704 of W. SAFE_P non-zero means ignore window-min-height|width but just
2705 return values that won't crash Emacs and don't hide components like
2706 fringes, scrollbars, or modelines. If WIDTH_P is zero and W is the
2707 minibuffer window, always return 1. */
2710 window_min_size_2 (struct window
*w
, int width_p
, int safe_p
)
2712 /* We should consider buffer-local values of window_min_height and
2713 window_min_width here. */
2716 int safe_size
= (MIN_SAFE_WINDOW_WIDTH
2717 + WINDOW_FRINGE_COLS (w
)
2718 + WINDOW_SCROLL_BAR_COLS (w
));
2720 return safe_p
? safe_size
: max (window_min_width
, safe_size
);
2722 else if (MINI_WINDOW_P (w
))
2726 int safe_size
= (MIN_SAFE_WINDOW_HEIGHT
2727 + ((BUFFERP (w
->buffer
)
2728 && !NILP (BVAR (XBUFFER (w
->buffer
), mode_line_format
)))
2731 return safe_p
? safe_size
: max (window_min_height
, safe_size
);
2735 /* Return minimum size of window W, not taking fixed-width windows into
2736 account. WIDTH_P non-zero means return the minimum width, otherwise
2737 return the minimum height. SAFE_P non-zero means ignore
2738 window-min-height|width but just return values that won't crash Emacs
2739 and don't hide components like fringes, scrollbars, or modelines. If
2740 W is a combination window, compute the minimum size from the minimum
2741 sizes of W's children. */
2744 window_min_size_1 (struct window
*w
, int width_p
, int safe_p
)
2749 if (!NILP (w
->hchild
))
2751 /* W is a horizontal combination. */
2752 c
= XWINDOW (w
->hchild
);
2757 /* The minimum width of a horizontal combination is the sum of
2758 the minimum widths of its children. */
2761 size
+= window_min_size_1 (c
, 1, safe_p
);
2762 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2767 /* The minimum height of a horizontal combination is the
2768 maximum of the minimum heights of its children. */
2771 size
= max (window_min_size_1 (c
, 0, safe_p
), size
);
2772 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2776 else if (!NILP (w
->vchild
))
2778 /* W is a vertical combination. */
2779 c
= XWINDOW (w
->vchild
);
2784 /* The minimum width of a vertical combination is the maximum
2785 of the minimum widths of its children. */
2788 size
= max (window_min_size_1 (c
, 1, safe_p
), size
);
2789 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2794 /* The minimum height of a vertical combination is the sum of
2795 the minimum height of its children. */
2798 size
+= window_min_size_1 (c
, 0, safe_p
);
2799 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2804 /* W is a leaf window. */
2805 size
= window_min_size_2 (w
, width_p
, safe_p
);
2810 /* Return the minimum size of window W, taking fixed-size windows into
2811 account. WIDTH_P non-zero means return the minimum width, otherwise
2812 return the minimum height. SAFE_P non-zero means ignore
2813 window-min-height|width but just return values that won't crash Emacs
2814 and don't hide components like fringes, scrollbars, or modelines.
2815 IGNORE_FIXED_P non-zero means ignore if W is fixed-size. Set *FIXED
2816 to 1 if W is fixed-size unless FIXED is null. */
2819 window_min_size (struct window
*w
, int width_p
, int safe_p
, int ignore_fixed_p
, int *fixed
)
2826 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2832 size
= WINDOW_TOTAL_SIZE (w
, width_p
);
2834 size
= window_min_size_1 (w
, width_p
, safe_p
);
2840 /* Adjust the margins of window W if text area is too small.
2841 Return 1 if window width is ok after adjustment; 0 if window
2842 is still too narrow. */
2845 adjust_window_margins (struct window
*w
)
2847 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2848 - WINDOW_FRINGE_COLS (w
)
2849 - WINDOW_SCROLL_BAR_COLS (w
));
2850 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2851 + WINDOW_RIGHT_MARGIN_COLS (w
));
2853 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2856 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2859 /* Window's text area is too narrow, but reducing the window
2860 margins will fix that. */
2861 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2862 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2864 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2865 w
->left_margin_cols
= w
->right_margin_cols
2866 = make_number (margin_cols
/2);
2868 w
->right_margin_cols
= make_number (margin_cols
);
2871 w
->left_margin_cols
= make_number (margin_cols
);
2875 /* Calculate new sizes for windows in the list FORWARD when their
2876 compound size goes from TOTAL to SIZE. TOTAL must be greater than
2877 SIZE. The number of windows in FORWARD is NCHILDREN, and the number
2878 that can shrink is SHRINKABLE. Fixed-size windows may be shrunk if
2879 and only if RESIZE_FIXED_P is non-zero. WIDTH_P non-zero means
2880 shrink columns, otherwise shrink lines.
2882 SAFE_P zero means windows may be sized down to window-min-height
2883 lines (window-min-window columns for WIDTH_P non-zero). SAFE_P
2884 non-zero means windows may be sized down to their minimum safe sizes
2885 taking into account the space needed to display modelines, fringes,
2888 This function returns an allocated array of new sizes that the caller
2889 must free. A size -1 means the window is fixed and RESIZE_FIXED_P is
2890 zero. A size zero means the window shall be deleted. Array index 0
2891 refers to the first window in FORWARD, 1 to the second, and so on.
2893 This function resizes windows proportionally to their size. It also
2894 tries to preserve smaller windows by resizing larger windows before
2895 resizing any window to zero. If resize_proportionally is non-nil for
2896 a specific window, it will attempt to strictly resize that window
2897 proportionally, even at the expense of deleting smaller windows. */
2899 shrink_windows (int total
, int size
, int nchildren
, int shrinkable
,
2900 int resize_fixed_p
, Lisp_Object forward
, int width_p
, int safe_p
)
2902 int available_resize
= 0;
2903 int *new_sizes
, *min_sizes
;
2906 int smallest
= total
;
2907 int total_removed
= 0;
2908 int total_shrink
= total
- size
;
2911 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2912 min_sizes
= xmalloc (sizeof (*min_sizes
) * nchildren
);
2914 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2918 c
= XWINDOW (child
);
2919 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
2921 if (!resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2925 new_sizes
[i
] = child_size
;
2926 min_sizes
[i
] = window_min_size_1 (c
, width_p
, safe_p
);
2927 if (child_size
> min_sizes
[i
]
2928 && NILP (c
->resize_proportionally
))
2929 available_resize
+= child_size
- min_sizes
[i
];
2932 /* We might need to shrink some windows to zero. Find the smallest
2933 windows and set them to 0 until we can fulfil the new size. */
2935 while (shrinkable
> 1 && size
+ available_resize
< total
)
2937 for (i
= 0; i
< nchildren
; ++i
)
2938 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2939 smallest
= new_sizes
[i
];
2941 for (i
= 0; i
< nchildren
; ++i
)
2942 if (new_sizes
[i
] == smallest
)
2944 /* Resize this window down to zero. */
2946 if (smallest
> min_sizes
[i
])
2947 available_resize
-= smallest
- min_sizes
[i
];
2948 available_resize
+= smallest
;
2950 total_removed
+= smallest
;
2952 /* We don't know what the smallest is now. */
2955 /* Out of for, just remove one window at the time and
2956 check again if we have enough space. */
2961 /* Now, calculate the new sizes. Try to shrink each window
2962 proportional to its size. */
2963 for (i
= 0; i
< nchildren
; ++i
)
2965 if (new_sizes
[i
] > min_sizes
[i
])
2967 int to_shrink
= total_shrink
* new_sizes
[i
] / total
;
2969 if (new_sizes
[i
] - to_shrink
< min_sizes
[i
])
2970 to_shrink
= new_sizes
[i
] - min_sizes
[i
];
2971 new_sizes
[i
] -= to_shrink
;
2972 total_removed
+= to_shrink
;
2976 /* Any reminder due to rounding, we just subtract from windows
2977 that are left and still can be shrunk. */
2978 while (total_shrink
> total_removed
)
2980 int nonzero_sizes
= 0;
2982 for (i
= 0; i
< nchildren
; ++i
)
2983 if (new_sizes
[i
] > 0)
2986 for (i
= 0; i
< nchildren
; ++i
)
2987 if (new_sizes
[i
] > min_sizes
[i
])
2992 /* Out of for, just shrink one window at the time and
2993 check again if we have enough space. */
2997 /* Special case, only one window left. */
2998 if (nonzero_sizes
== 1)
3002 /* Any surplus due to rounding, we add to windows that are left. */
3003 while (total_shrink
< total_removed
)
3005 for (i
= 0; i
< nchildren
; ++i
)
3007 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
3021 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
3022 WINDOW's width. Resize WINDOW's children, if any, so that they keep
3023 their proportionate size relative to WINDOW.
3025 If FIRST_ONLY is 1, change only the first of WINDOW's children when
3026 they are in series. If LAST_ONLY is 1, change only the last of
3027 WINDOW's children when they are in series.
3029 Propagate WINDOW's top or left edge position to children. Delete
3030 windows that become too small unless NODELETE_P is 1. When
3031 NODELETE_P equals 2 do not honor settings for window-min-height and
3032 window-min-width when resizing windows but use safe defaults instead.
3033 This should give better behavior when resizing frames. */
3036 size_window (Lisp_Object window
, int size
, int width_p
, int nodelete_p
, int first_only
, int last_only
)
3038 struct window
*w
= XWINDOW (window
);
3040 Lisp_Object child
, *forward
, *sideward
;
3041 int old_size
= WINDOW_TOTAL_SIZE (w
, width_p
);
3043 size
= max (0, size
);
3045 /* Delete WINDOW if it's too small. */
3046 if (nodelete_p
!= 1 && !NILP (w
->parent
)
3047 && size
< window_min_size_1 (w
, width_p
, nodelete_p
== 2))
3049 delete_window (window
);
3053 /* Set redisplay hints. */
3054 w
->last_modified
= make_number (0);
3055 w
->last_overlay_modified
= make_number (0);
3056 windows_or_buffers_changed
++;
3057 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3061 sideward
= &w
->vchild
;
3062 forward
= &w
->hchild
;
3063 w
->total_cols
= make_number (size
);
3064 adjust_window_margins (w
);
3068 sideward
= &w
->hchild
;
3069 forward
= &w
->vchild
;
3070 w
->total_lines
= make_number (size
);
3071 w
->orig_total_lines
= Qnil
;
3074 if (!NILP (*sideward
))
3076 /* We have a chain of parallel siblings whose size should all change. */
3077 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3079 c
= XWINDOW (child
);
3081 c
->left_col
= w
->left_col
;
3083 c
->top_line
= w
->top_line
;
3084 size_window (child
, size
, width_p
, nodelete_p
,
3085 first_only
, last_only
);
3088 else if (!NILP (*forward
) && last_only
)
3090 /* Change the last in a series of siblings. */
3091 Lisp_Object last_child
;
3094 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3096 c
= XWINDOW (child
);
3100 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3101 size_window (last_child
, size
- old_size
+ child_size
,
3102 width_p
, nodelete_p
, first_only
, last_only
);
3104 else if (!NILP (*forward
) && first_only
)
3106 /* Change the first in a series of siblings. */
3110 c
= XWINDOW (child
);
3113 c
->left_col
= w
->left_col
;
3115 c
->top_line
= w
->top_line
;
3117 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3118 size_window (child
, size
- old_size
+ child_size
,
3119 width_p
, nodelete_p
, first_only
, last_only
);
3121 else if (!NILP (*forward
))
3123 int fixed_size
, each
IF_LINT (= 0), extra
IF_LINT (= 0), n
;
3124 int resize_fixed_p
, nfixed
;
3125 int last_pos
, first_pos
, nchildren
, total
;
3126 int *new_sizes
= NULL
;
3128 /* Determine the fixed-size portion of this window, and the
3129 number of child windows. */
3130 fixed_size
= nchildren
= nfixed
= total
= 0;
3131 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3135 c
= XWINDOW (child
);
3136 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3137 total
+= child_size
;
3139 if (window_fixed_size_p (c
, width_p
, 0))
3141 fixed_size
+= child_size
;
3146 /* If the new size is smaller than fixed_size, or if there
3147 aren't any resizable windows, allow resizing fixed-size
3149 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3151 /* Compute how many lines/columns to add/remove to each child. The
3152 value of extra takes care of rounding errors. */
3153 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3154 if (size
< total
&& n
> 1)
3155 new_sizes
= shrink_windows (total
, size
, nchildren
, n
,
3156 resize_fixed_p
, *forward
, width_p
,
3160 each
= (size
- total
) / n
;
3161 extra
= (size
- total
) - n
* each
;
3164 /* Compute new children heights and edge positions. */
3165 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3166 last_pos
= first_pos
;
3167 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3169 int new_child_size
, old_child_size
;
3171 c
= XWINDOW (child
);
3172 old_child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3173 new_child_size
= old_child_size
;
3175 /* The top or left edge position of this child equals the
3176 bottom or right edge of its predecessor. */
3178 c
->left_col
= make_number (last_pos
);
3180 c
->top_line
= make_number (last_pos
);
3182 /* If this child can be resized, do it. */
3183 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3186 new_sizes
? new_sizes
[n
] : old_child_size
+ each
+ extra
;
3190 /* Set new size. Note that size_window also propagates
3191 edge positions to children, so it's not a no-op if we
3192 didn't change the child's size. */
3193 size_window (child
, new_child_size
, width_p
, 1,
3194 first_only
, last_only
);
3196 /* Remember the bottom/right edge position of this child; it
3197 will be used to set the top/left edge of the next child. */
3198 last_pos
+= new_child_size
;
3203 /* We should have covered the parent exactly with child windows. */
3204 xassert (size
== last_pos
- first_pos
);
3206 /* Now delete any children that became too small. */
3207 if (nodelete_p
!= 1)
3208 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3212 c
= XWINDOW (child
);
3213 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3214 size_window (child
, child_size
, width_p
, nodelete_p
,
3215 first_only
, last_only
);
3220 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3221 WINDOW's children. NODELETE zero means windows that have become
3222 smaller than window-min-height in the process may be deleted.
3223 NODELETE 1 means never delete windows that become too small in the
3224 process. (The caller should check later and do so if appropriate.)
3225 NODELETE 2 means delete only windows that have become too small to be
3226 displayed correctly. */
3229 set_window_height (Lisp_Object window
, int height
, int nodelete
)
3231 size_window (window
, height
, 0, nodelete
, 0, 0);
3234 /* Set WINDOW's width to WIDTH, and recursively change the width of
3235 WINDOW's children. NODELETE zero means windows that have become
3236 smaller than window-min-width in the process may be deleted.
3237 NODELETE 1 means never delete windows that become too small in the
3238 process. (The caller should check later and do so if appropriate.)
3239 NODELETE 2 means delete only windows that have become too small to be
3240 displayed correctly. */
3243 set_window_width (Lisp_Object window
, int width
, int nodelete
)
3245 size_window (window
, width
, 1, nodelete
, 0, 0);
3248 /* Change window heights in windows rooted in WINDOW by N lines. */
3251 change_window_heights (Lisp_Object window
, int n
)
3253 struct window
*w
= XWINDOW (window
);
3255 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3256 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3258 if (INTEGERP (w
->orig_top_line
))
3259 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3260 if (INTEGERP (w
->orig_total_lines
))
3261 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3263 /* Handle just the top child in a vertical split. */
3264 if (!NILP (w
->vchild
))
3265 change_window_heights (w
->vchild
, n
);
3267 /* Adjust all children in a horizontal split. */
3268 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3270 w
= XWINDOW (window
);
3271 change_window_heights (window
, n
);
3276 int window_select_count
;
3278 EXFUN (Fset_window_fringes
, 4);
3279 EXFUN (Fset_window_scroll_bars
, 4);
3282 run_funs (Lisp_Object funs
)
3284 for (; CONSP (funs
); funs
= XCDR (funs
))
3285 if (!EQ (XCAR (funs
), Qt
))
3286 call0 (XCAR (funs
));
3289 static Lisp_Object
select_window_norecord (Lisp_Object window
);
3290 static Lisp_Object
select_frame_norecord (Lisp_Object frame
);
3293 run_window_configuration_change_hook (struct frame
*f
)
3295 int count
= SPECPDL_INDEX ();
3296 Lisp_Object frame
, global_wcch
3297 = Fdefault_value (Qwindow_configuration_change_hook
);
3298 XSETFRAME (frame
, f
);
3300 if (NILP (Vrun_hooks
))
3303 if (SELECTED_FRAME () != f
)
3305 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3306 Fselect_frame (frame
, Qt
);
3309 /* Use the right buffer. Matters when running the local hooks. */
3310 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3312 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3313 Fset_buffer (Fwindow_buffer (Qnil
));
3316 /* Look for buffer-local values. */
3318 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3319 for (; CONSP (windows
); windows
= XCDR (windows
))
3321 Lisp_Object window
= XCAR (windows
);
3322 Lisp_Object buffer
= Fwindow_buffer (window
);
3323 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3326 int count1
= SPECPDL_INDEX ();
3327 record_unwind_protect (select_window_norecord
, Fselected_window ());
3328 select_window_norecord (window
);
3329 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3331 unbind_to (count1
, Qnil
);
3336 run_funs (global_wcch
);
3337 unbind_to (count
, Qnil
);
3340 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3341 means it's allowed to run hooks. See make_frame for a case where
3342 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3343 margins, fringes, and scroll-bar settings of the window are not
3344 reset from the buffer's local settings. */
3347 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3349 struct window
*w
= XWINDOW (window
);
3350 struct buffer
*b
= XBUFFER (buffer
);
3351 int count
= SPECPDL_INDEX ();
3352 int samebuf
= EQ (buffer
, w
->buffer
);
3356 if (EQ (window
, selected_window
))
3357 BVAR (b
, last_selected_window
) = window
;
3359 /* Let redisplay errors through. */
3360 b
->display_error_modiff
= 0;
3362 /* Update time stamps of buffer display. */
3363 if (INTEGERP (BVAR (b
, display_count
)))
3364 XSETINT (BVAR (b
, display_count
), XINT (BVAR (b
, display_count
)) + 1);
3365 BVAR (b
, display_time
) = Fcurrent_time ();
3367 XSETFASTINT (w
->window_end_pos
, 0);
3368 XSETFASTINT (w
->window_end_vpos
, 0);
3369 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3370 w
->window_end_valid
= Qnil
;
3371 if (!(keep_margins_p
&& samebuf
))
3372 { /* If we're not actually changing the buffer, don't reset hscroll and
3373 vscroll. This case happens for example when called from
3374 change_frame_size_1, where we use a dummy call to
3375 Fset_window_buffer on the frame's selected window (and no other)
3376 just in order to run window-configuration-change-hook.
3377 Resetting hscroll and vscroll here is problematic for things like
3378 image-mode and doc-view-mode since it resets the image's position
3379 whenever we resize the frame. */
3380 w
->hscroll
= w
->min_hscroll
= make_number (0);
3382 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3383 set_marker_restricted (w
->start
,
3384 make_number (b
->last_window_start
),
3386 w
->start_at_line_beg
= Qnil
;
3387 w
->force_start
= Qnil
;
3388 XSETFASTINT (w
->last_modified
, 0);
3389 XSETFASTINT (w
->last_overlay_modified
, 0);
3391 /* Maybe we could move this into the `if' but it's not obviously safe and
3392 I doubt it's worth the trouble. */
3393 windows_or_buffers_changed
++;
3395 /* We must select BUFFER for running the window-scroll-functions. */
3396 /* We can't check ! NILP (Vwindow_scroll_functions) here
3397 because that might itself be a local variable. */
3398 if (window_initialized
)
3400 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3401 Fset_buffer (buffer
);
3404 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3406 if (!keep_margins_p
)
3408 /* Set left and right marginal area width etc. from buffer. */
3410 /* This may call adjust_window_margins three times, so
3411 temporarily disable window margins. */
3412 Lisp_Object save_left
= w
->left_margin_cols
;
3413 Lisp_Object save_right
= w
->right_margin_cols
;
3415 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3417 Fset_window_fringes (window
,
3418 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3419 BVAR (b
, fringes_outside_margins
));
3421 Fset_window_scroll_bars (window
,
3422 BVAR (b
, scroll_bar_width
),
3423 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3425 w
->left_margin_cols
= save_left
;
3426 w
->right_margin_cols
= save_right
;
3428 Fset_window_margins (window
,
3429 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3434 if (! NILP (Vwindow_scroll_functions
))
3435 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3436 Fmarker_position (w
->start
));
3437 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3440 unbind_to (count
, Qnil
);
3444 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3445 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3446 WINDOW defaults to the selected window. BUFFER-OR-NAME must be a buffer
3447 or the name of an existing buffer. Optional third argument KEEP-MARGINS
3448 non-nil means that WINDOW's current display margins, fringe widths, and
3449 scroll bar settings are preserved; the default is to reset these from
3450 the local settings for BUFFER-OR-NAME or the frame defaults. Return nil.
3452 This function throws an error when WINDOW is strongly dedicated to its
3453 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3454 already display BUFFER-OR-NAME.
3456 This function runs `window-scroll-functions' before running
3457 `window-configuration-change-hook'. */)
3458 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3460 register Lisp_Object tem
, buffer
;
3461 register struct window
*w
= decode_window (window
);
3463 XSETWINDOW (window
, w
);
3464 buffer
= Fget_buffer (buffer_or_name
);
3465 CHECK_BUFFER (buffer
);
3466 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3467 error ("Attempt to display deleted buffer");
3471 error ("Window is deleted");
3472 else if (!EQ (tem
, Qt
))
3473 /* w->buffer is t when the window is first being set up. */
3475 if (EQ (tem
, buffer
))
3477 else if (EQ (w
->dedicated
, Qt
))
3478 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3480 w
->dedicated
= Qnil
;
3485 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3489 /* If select_window is called with inhibit_point_swap non-zero it will
3490 not store point of the old selected window's buffer back into that
3491 window's pointm slot. This is needed by Fset_window_configuration to
3492 avoid that the display routine is called with selected_window set to
3493 Qnil causing a subsequent crash. */
3496 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
3498 register struct window
*w
;
3499 register struct window
*ow
;
3502 CHECK_LIVE_WINDOW (window
);
3504 w
= XWINDOW (window
);
3505 w
->frozen_window_start_p
= 0;
3507 if (NILP (norecord
))
3509 ++window_select_count
;
3510 XSETFASTINT (w
->use_time
, window_select_count
);
3511 record_buffer (w
->buffer
);
3514 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
3517 sf
= SELECTED_FRAME ();
3518 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3520 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3521 /* Use this rather than Fhandle_switch_frame
3522 so that FRAME_FOCUS_FRAME is moved appropriately as we
3523 move around in the state where a minibuffer in a separate
3525 Fselect_frame (WINDOW_FRAME (w
), norecord
);
3526 /* Fselect_frame called us back so we've done all the work already. */
3527 eassert (EQ (window
, selected_window
));
3531 sf
->selected_window
= window
;
3533 /* Store the current buffer's actual point into the
3534 old selected window. It belongs to that window,
3535 and when the window is not selected, must be in the window. */
3536 if (!inhibit_point_swap
)
3538 ow
= XWINDOW (selected_window
);
3539 if (! NILP (ow
->buffer
))
3540 set_marker_both (ow
->pointm
, ow
->buffer
,
3541 BUF_PT (XBUFFER (ow
->buffer
)),
3542 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3545 selected_window
= window
;
3547 Fset_buffer (w
->buffer
);
3549 BVAR (XBUFFER (w
->buffer
), last_selected_window
) = window
;
3551 /* Go to the point recorded in the window.
3552 This is important when the buffer is in more
3553 than one window. It also matters when
3554 redisplay_window has altered point after scrolling,
3555 because it makes the change only in the window. */
3557 register EMACS_INT new_point
= marker_position (w
->pointm
);
3558 if (new_point
< BEGV
)
3560 else if (new_point
> ZV
)
3566 windows_or_buffers_changed
++;
3571 /* Note that selected_window can be nil when this is called from
3572 Fset_window_configuration. */
3574 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3575 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3576 If WINDOW is not already selected, make WINDOW's buffer current
3577 and make WINDOW the frame's selected window. Return WINDOW.
3578 Optional second arg NORECORD non-nil means do not put this buffer
3579 at the front of the list of recently selected ones and do not
3580 make this window the most recently selected one.
3582 Note that the main editor command loop selects the buffer of the
3583 selected window before each command. */)
3584 (register Lisp_Object window
, Lisp_Object norecord
)
3586 return select_window (window
, norecord
, 0);
3590 select_window_norecord (Lisp_Object window
)
3592 return WINDOW_LIVE_P (window
)
3593 ? Fselect_window (window
, Qt
) : selected_window
;
3597 select_frame_norecord (Lisp_Object frame
)
3599 return FRAME_LIVE_P (XFRAME (frame
))
3600 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3604 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3606 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3609 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3611 doc
: /* Force all windows to be updated on next redisplay.
3612 If optional arg OBJECT is a window, force redisplay of that window only.
3613 If OBJECT is a buffer or buffer name, force redisplay of all windows
3614 displaying that buffer. */)
3615 (Lisp_Object object
)
3619 windows_or_buffers_changed
++;
3620 update_mode_lines
++;
3624 if (WINDOWP (object
))
3626 struct window
*w
= XWINDOW (object
);
3627 mark_window_display_accurate (object
, 0);
3628 w
->update_mode_line
= Qt
;
3629 if (BUFFERP (w
->buffer
))
3630 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3631 ++update_mode_lines
;
3635 if (STRINGP (object
))
3636 object
= Fget_buffer (object
);
3637 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3639 /* Walk all windows looking for buffer, and force update
3640 of each of those windows. */
3642 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3643 return NILP (object
) ? Qnil
: Qt
;
3646 /* If nothing suitable was found, just return.
3647 We could signal an error, but this feature will typically be used
3648 asynchronously in timers or process sentinels, so we don't. */
3654 temp_output_buffer_show (register Lisp_Object buf
)
3656 register struct buffer
*old
= current_buffer
;
3657 register Lisp_Object window
;
3658 register struct window
*w
;
3660 BVAR (XBUFFER (buf
), directory
) = BVAR (current_buffer
, directory
);
3663 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3667 set_buffer_internal (old
);
3669 if (!NILP (Vtemp_buffer_show_function
))
3670 call1 (Vtemp_buffer_show_function
, buf
);
3673 window
= display_buffer (buf
, Qnil
, Qnil
);
3675 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3676 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3677 Vminibuf_scroll_window
= window
;
3678 w
= XWINDOW (window
);
3679 XSETFASTINT (w
->hscroll
, 0);
3680 XSETFASTINT (w
->min_hscroll
, 0);
3681 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3682 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3684 /* Run temp-buffer-show-hook, with the chosen window selected
3685 and its buffer current. */
3687 int count
= SPECPDL_INDEX ();
3688 Lisp_Object prev_window
, prev_buffer
;
3689 prev_window
= selected_window
;
3690 XSETBUFFER (prev_buffer
, old
);
3692 /* Select the window that was chosen, for running the hook.
3693 Note: Both Fselect_window and select_window_norecord may
3694 set-buffer to the buffer displayed in the window,
3695 so we need to save the current buffer. --stef */
3696 record_unwind_protect (Fset_buffer
, prev_buffer
);
3697 record_unwind_protect (select_window_norecord
, prev_window
);
3698 Fselect_window (window
, Qt
);
3699 Fset_buffer (w
->buffer
);
3700 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3701 unbind_to (count
, Qnil
);
3706 DEFUN ("internal-temp-output-buffer-show",
3707 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3709 doc
: /* Internal function for `with-output-to-temp-buffer''. */)
3712 temp_output_buffer_show (buf
);
3717 make_dummy_parent (Lisp_Object window
)
3720 register struct window
*o
, *p
;
3723 o
= XWINDOW (window
);
3724 p
= allocate_window ();
3725 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3726 ((struct Lisp_Vector
*) p
)->contents
[i
]
3727 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3728 XSETWINDOW (new, p
);
3731 XSETFASTINT (p
->sequence_number
, sequence_number
);
3733 /* Put new into window structure in place of window */
3734 replace_window (window
, new);
3747 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3748 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3749 WINDOW defaults to selected one and SIZE to half its size.
3750 If optional third arg HORIZONTAL is non-nil, split side by side and put
3751 SIZE columns in the first of the pair. In that case, SIZE includes that
3752 window's scroll bar, or the divider column to its right.
3753 Interactively, all arguments are nil.
3754 Returns the newly created window (which is the lower or rightmost one).
3755 The upper or leftmost window is the original one, and remains selected
3756 if it was selected before.
3758 See Info node `(elisp)Splitting Windows' for more details and examples. */)
3759 (Lisp_Object window
, Lisp_Object size
, Lisp_Object horizontal
)
3761 register Lisp_Object
new;
3762 register struct window
*o
, *p
;
3764 register int size_int
;
3767 window
= selected_window
;
3769 CHECK_LIVE_WINDOW (window
);
3771 o
= XWINDOW (window
);
3772 fo
= XFRAME (WINDOW_FRAME (o
));
3776 if (!NILP (horizontal
))
3777 /* Calculate the size of the left-hand window, by dividing
3778 the usable space in columns by two.
3779 We round up, since the left-hand window may include
3780 a dividing line, while the right-hand may not. */
3781 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3783 size_int
= XFASTINT (o
->total_lines
) >> 1;
3787 CHECK_NUMBER (size
);
3788 size_int
= XINT (size
);
3791 if (MINI_WINDOW_P (o
))
3792 error ("Attempt to split minibuffer window");
3793 else if (window_fixed_size_p (o
, !NILP (horizontal
), 0))
3794 error ("Attempt to split fixed-size window");
3796 if (NILP (horizontal
))
3798 int window_safe_height
= window_min_size_2 (o
, 0, 0);
3800 if (size_int
< window_safe_height
)
3801 error ("Window height %d too small (after splitting)", size_int
);
3802 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
3803 error ("Window height %d too small (after splitting)",
3804 (int) (XFASTINT (o
->total_lines
) - size_int
));
3805 if (NILP (o
->parent
)
3806 || NILP (XWINDOW (o
->parent
)->vchild
))
3808 make_dummy_parent (window
);
3810 XWINDOW (new)->vchild
= window
;
3815 int window_safe_width
= window_min_size_2 (o
, 1, 0);
3817 if (size_int
< window_safe_width
)
3818 error ("Window width %d too small (after splitting)", size_int
);
3819 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
3820 error ("Window width %d too small (after splitting)",
3821 (int) (XFASTINT (o
->total_cols
) - size_int
));
3822 if (NILP (o
->parent
)
3823 || NILP (XWINDOW (o
->parent
)->hchild
))
3825 make_dummy_parent (window
);
3827 XWINDOW (new)->hchild
= window
;
3831 /* Now we know that window's parent is a vertical combination
3832 if we are dividing vertically, or a horizontal combination
3833 if we are making side-by-side windows */
3835 windows_or_buffers_changed
++;
3836 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3837 new = make_window ();
3840 p
->frame
= o
->frame
;
3842 if (!NILP (p
->next
))
3843 XWINDOW (p
->next
)->prev
= new;
3846 p
->parent
= o
->parent
;
3848 p
->window_end_valid
= Qnil
;
3849 memset (&p
->last_cursor
, 0, sizeof p
->last_cursor
);
3851 /* Duplicate special geometry settings. */
3853 p
->left_margin_cols
= o
->left_margin_cols
;
3854 p
->right_margin_cols
= o
->right_margin_cols
;
3855 p
->left_fringe_width
= o
->left_fringe_width
;
3856 p
->right_fringe_width
= o
->right_fringe_width
;
3857 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3858 p
->scroll_bar_width
= o
->scroll_bar_width
;
3859 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3861 /* Apportion the available frame space among the two new windows */
3863 if (!NILP (horizontal
))
3865 p
->total_lines
= o
->total_lines
;
3866 p
->top_line
= o
->top_line
;
3867 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3868 XSETFASTINT (o
->total_cols
, size_int
);
3869 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3870 adjust_window_margins (p
);
3871 adjust_window_margins (o
);
3875 p
->left_col
= o
->left_col
;
3876 p
->total_cols
= o
->total_cols
;
3877 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3878 XSETFASTINT (o
->total_lines
, size_int
);
3879 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3882 /* Adjust glyph matrices. */
3885 Fset_window_buffer (new, o
->buffer
, Qt
);
3889 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3890 doc
: /* Make selected window SIZE lines taller.
3891 Interactively, if no argument is given, make the selected window one
3892 line taller. If optional argument HORIZONTAL is non-nil, make selected
3893 window wider by SIZE columns. If SIZE is negative, shrink the window by
3894 -SIZE lines or columns. Return nil.
3896 This function can delete windows if they get too small. The size of
3897 fixed size windows is not altered by this function. */)
3898 (Lisp_Object size
, Lisp_Object horizontal
)
3900 CHECK_NUMBER (size
);
3901 enlarge_window (selected_window
, XINT (size
), !NILP (horizontal
));
3903 run_window_configuration_change_hook (SELECTED_FRAME ());
3908 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3909 doc
: /* Make selected window SIZE lines smaller.
3910 Interactively, if no argument is given, make the selected window one
3911 line smaller. If optional argument HORIZONTAL is non-nil, make the
3912 window narrower by SIZE columns. If SIZE is negative, enlarge selected
3913 window by -SIZE lines or columns. Return nil.
3915 This function can delete windows if they get too small. The size of
3916 fixed size windows is not altered by this function. */)
3917 (Lisp_Object size
, Lisp_Object horizontal
)
3919 CHECK_NUMBER (size
);
3920 enlarge_window (selected_window
, -XINT (size
), !NILP (horizontal
));
3922 run_window_configuration_change_hook (SELECTED_FRAME ());
3928 window_height (Lisp_Object window
)
3930 register struct window
*p
= XWINDOW (window
);
3931 return WINDOW_TOTAL_LINES (p
);
3935 window_width (Lisp_Object window
)
3937 register struct window
*p
= XWINDOW (window
);
3938 return WINDOW_TOTAL_COLS (p
);
3943 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3945 #define CURSIZE(w) \
3946 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3949 /* Enlarge WINDOW by DELTA. HORIZ_FLAG nonzero means enlarge it
3950 horizontally; zero means do it vertically.
3952 Siblings of the selected window are resized to fulfill the size
3953 request. If they become too small in the process, they may be
3957 enlarge_window (Lisp_Object window
, int delta
, int horiz_flag
)
3959 Lisp_Object parent
, next
, prev
;
3963 int (*sizefun
) (Lisp_Object
)
3964 = horiz_flag
? window_width
: window_height
;
3965 void (*setsizefun
) (Lisp_Object
, int, int)
3966 = (horiz_flag
? set_window_width
: set_window_height
);
3968 /* Give up if this window cannot be resized. */
3969 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3970 error ("Window is not resizable");
3972 /* Find the parent of the selected window. */
3975 p
= XWINDOW (window
);
3981 error ("No other window to side of this one");
3986 ? !NILP (XWINDOW (parent
)->hchild
)
3987 : !NILP (XWINDOW (parent
)->vchild
))
3993 sizep
= &CURSIZE (window
);
3996 register int maxdelta
;
3998 /* Compute the maximum size increment this window can have. */
4000 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4001 /* This is a main window followed by a minibuffer. */
4002 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4003 - window_min_size (XWINDOW (p
->next
),
4004 horiz_flag
, 0, 0, 0))
4005 /* This is a minibuffer following a main window. */
4006 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4007 - window_min_size (XWINDOW (p
->prev
),
4008 horiz_flag
, 0, 0, 0))
4009 /* This is a frame with only one window, a minibuffer-only
4010 or a minibufferless frame. */
4013 if (delta
> maxdelta
)
4014 /* This case traps trying to make the minibuffer
4015 the full frame, or make the only window aside from the
4016 minibuffer the full frame. */
4020 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
),
4021 horiz_flag
, 0, 0, 0))
4023 delete_window (window
);
4030 /* Find the total we can get from other siblings without deleting them. */
4032 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4033 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4034 horiz_flag
, 0, 0, 0);
4035 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4036 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4037 horiz_flag
, 0, 0, 0);
4039 /* If we can get it all from them without deleting them, do so. */
4040 if (delta
<= maximum
)
4042 Lisp_Object first_unaffected
;
4043 Lisp_Object first_affected
;
4048 first_affected
= window
;
4049 /* Look at one sibling at a time,
4050 moving away from this window in both directions alternately,
4051 and take as much as we can get without deleting that sibling. */
4053 && (!NILP (next
) || !NILP (prev
)))
4057 int this_one
= ((*sizefun
) (next
)
4058 - window_min_size (XWINDOW (next
), horiz_flag
,
4062 if (this_one
> delta
)
4065 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4066 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4071 next
= XWINDOW (next
)->next
;
4079 int this_one
= ((*sizefun
) (prev
)
4080 - window_min_size (XWINDOW (prev
), horiz_flag
,
4084 if (this_one
> delta
)
4087 first_affected
= prev
;
4089 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4090 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4095 prev
= XWINDOW (prev
)->prev
;
4099 xassert (delta
== 0);
4101 /* Now recalculate the edge positions of all the windows affected,
4102 based on the new sizes. */
4103 first_unaffected
= next
;
4104 prev
= first_affected
;
4105 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4106 prev
= next
, next
= XWINDOW (next
)->next
)
4108 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4109 /* This does not change size of NEXT,
4110 but it propagates the new top edge to its children */
4111 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4116 register int delta1
;
4117 register int opht
= (*sizefun
) (parent
);
4119 if (opht
<= XINT (*sizep
) + delta
)
4121 /* If trying to grow this window to or beyond size of the parent,
4122 just delete all the sibling windows. */
4123 Lisp_Object start
, tem
;
4125 start
= XWINDOW (parent
)->vchild
;
4127 start
= XWINDOW (parent
)->hchild
;
4129 /* Delete any siblings that come after WINDOW. */
4130 tem
= XWINDOW (window
)->next
;
4131 while (! NILP (tem
))
4133 Lisp_Object next1
= XWINDOW (tem
)->next
;
4134 delete_window (tem
);
4138 /* Delete any siblings that come after WINDOW.
4139 Note that if START is not WINDOW, then WINDOW still
4140 has siblings, so WINDOW has not yet replaced its parent. */
4142 while (! EQ (tem
, window
))
4144 Lisp_Object next1
= XWINDOW (tem
)->next
;
4145 delete_window (tem
);
4151 /* Otherwise, make delta1 just right so that if we add
4152 delta1 lines to this window and to the parent, and then
4153 shrink the parent back to its original size, the new
4154 proportional size of this window will increase by delta.
4156 The function size_window will compute the new height h'
4157 of the window from delta1 as:
4160 x = delta1 - delta1/n * n for the 1st resizable child
4163 where n is the number of children that can be resized.
4164 We can ignore x by choosing a delta1 that is a multiple of
4165 n. We want the height of this window to come out as
4175 The number of children n equals the number of resizable
4176 children of this window + 1 because we know window itself
4177 is resizable (otherwise we would have signaled an error).
4179 This reasoning is not correct when other windows become too
4180 small and shrink_windows refuses to delete them. Below we
4181 use resize_proportionally to work around this problem. */
4183 struct window
*w
= XWINDOW (window
);
4187 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4188 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4190 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4191 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4196 /* Add delta1 lines or columns to this window, and to the parent,
4197 keeping things consistent while not affecting siblings. */
4198 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4199 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4201 /* Squeeze out delta1 lines or columns from our parent,
4202 shrinking this window and siblings proportionately. This
4203 brings parent back to correct size. Delta1 was calculated
4204 so this makes this window the desired size, taking it all
4205 out of the siblings.
4207 Temporarily set resize_proportionally to Qt to assure that,
4208 if necessary, shrink_windows deletes smaller windows rather
4209 than shrink this window. */
4210 w
->resize_proportionally
= Qt
;
4211 (*setsizefun
) (parent
, opht
, 0);
4212 w
->resize_proportionally
= Qnil
;
4216 XSETFASTINT (p
->last_modified
, 0);
4217 XSETFASTINT (p
->last_overlay_modified
, 0);
4219 /* Adjust glyph matrices. */
4220 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4224 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4225 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4226 zero means adjust the height, moving the bottom edge.
4228 Following siblings of the selected window are resized to fulfill
4229 the size request. If they become too small in the process, they
4230 are not deleted; instead, we signal an error. */
4233 adjust_window_trailing_edge (Lisp_Object window
, int delta
, int horiz_flag
)
4235 Lisp_Object parent
, child
;
4237 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4238 int delcount
= window_deletion_count
;
4240 CHECK_WINDOW (window
);
4242 /* Give up if this window cannot be resized. */
4243 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4244 error ("Window is not resizable");
4248 Lisp_Object first_parallel
= Qnil
;
4252 /* This happens if WINDOW on the previous iteration was
4253 at top level of the window tree. */
4254 Fset_window_configuration (old_config
);
4255 error ("Specified window edge is fixed");
4258 p
= XWINDOW (window
);
4261 /* See if this level has windows in parallel in the specified
4262 direction. If so, set FIRST_PARALLEL to the first one. */
4265 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4266 first_parallel
= XWINDOW (parent
)->vchild
;
4267 else if (NILP (parent
) && !NILP (p
->next
))
4269 /* Handle the vertical chain of main window and minibuffer
4270 which has no parent. */
4271 first_parallel
= window
;
4272 while (! NILP (XWINDOW (first_parallel
)->prev
))
4273 first_parallel
= XWINDOW (first_parallel
)->prev
;
4278 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4279 first_parallel
= XWINDOW (parent
)->hchild
;
4282 /* If this level's succession is in the desired dimension,
4283 and this window is the last one, and there is no higher level,
4284 its trailing edge is fixed. */
4285 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4288 Fset_window_configuration (old_config
);
4289 error ("Specified window edge is fixed");
4292 /* Don't make this window too small. */
4293 if (XINT (CURSIZE (window
)) + delta
4294 < window_min_size_2 (XWINDOW (window
), horiz_flag
, 0))
4296 Fset_window_configuration (old_config
);
4297 error ("Cannot adjust window size as specified");
4300 /* Clear out some redisplay caches. */
4301 XSETFASTINT (p
->last_modified
, 0);
4302 XSETFASTINT (p
->last_overlay_modified
, 0);
4304 /* Adjust this window's edge. */
4305 XSETINT (CURSIZE (window
),
4306 XINT (CURSIZE (window
)) + delta
);
4308 /* If this window has following siblings in the desired dimension,
4309 make them smaller, and exit the loop.
4311 (If we reach the top of the tree and can never do this,
4312 we will fail and report an error, above.) */
4313 if (NILP (first_parallel
))
4315 if (!NILP (p
->next
))
4317 /* This may happen for the minibuffer. In that case
4318 the window_deletion_count check below does not work. */
4319 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4321 Fset_window_configuration (old_config
);
4322 error ("Cannot adjust window size as specified");
4325 XSETINT (CURBEG (p
->next
),
4326 XINT (CURBEG (p
->next
)) + delta
);
4327 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4328 horiz_flag
, 0, 1, 0);
4333 /* Here we have a chain of parallel siblings, in the other dimension.
4334 Change the size of the other siblings. */
4335 for (child
= first_parallel
;
4337 child
= XWINDOW (child
)->next
)
4338 if (! EQ (child
, window
))
4339 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4340 horiz_flag
, 0, 0, 1);
4345 /* If we made a window so small it got deleted,
4346 we failed. Report failure. */
4347 if (delcount
!= window_deletion_count
)
4349 Fset_window_configuration (old_config
);
4350 error ("Cannot adjust window size as specified");
4353 /* Adjust glyph matrices. */
4354 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4360 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4361 Sadjust_window_trailing_edge
, 3, 3, 0,
4362 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4363 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4364 Otherwise, adjust the height, moving the bottom edge.
4366 Following siblings of the selected window are resized to fulfill
4367 the size request. If they become too small in the process, they
4368 are not deleted; instead, we signal an error. */)
4369 (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
)
4371 CHECK_NUMBER (delta
);
4373 window
= selected_window
;
4374 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4376 run_window_configuration_change_hook
4377 (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4384 /***********************************************************************
4385 Resizing Mini-Windows
4386 ***********************************************************************/
4388 static void shrink_window_lowest_first (struct window
*, int);
4390 enum save_restore_action
4397 static int save_restore_orig_size (struct window
*,
4398 enum save_restore_action
);
4400 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4401 from lowest windows first. */
4404 shrink_window_lowest_first (struct window
*w
, int height
)
4410 xassert (!MINI_WINDOW_P (w
));
4412 /* Set redisplay hints. */
4413 XSETFASTINT (w
->last_modified
, 0);
4414 XSETFASTINT (w
->last_overlay_modified
, 0);
4415 windows_or_buffers_changed
++;
4416 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4418 old_height
= XFASTINT (w
->total_lines
);
4419 XSETFASTINT (w
->total_lines
, height
);
4421 if (!NILP (w
->hchild
))
4423 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4425 c
= XWINDOW (child
);
4426 c
->top_line
= w
->top_line
;
4427 shrink_window_lowest_first (c
, height
);
4430 else if (!NILP (w
->vchild
))
4432 Lisp_Object last_child
;
4433 int delta
= old_height
- height
;
4438 /* Find the last child. We are taking space from lowest windows
4439 first, so we iterate over children from the last child
4441 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4444 /* Size children down to their safe heights. */
4445 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4449 c
= XWINDOW (child
);
4450 this_one
= XFASTINT (c
->total_lines
) - window_min_size_1 (c
, 0, 1);
4452 if (this_one
> delta
)
4455 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4459 /* Compute new positions. */
4460 last_top
= XINT (w
->top_line
);
4461 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4463 c
= XWINDOW (child
);
4464 c
->top_line
= make_number (last_top
);
4465 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4466 last_top
+= XFASTINT (c
->total_lines
);
4472 /* Save, restore, or check positions and sizes in the window tree
4473 rooted at W. ACTION says what to do.
4475 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4476 orig_total_lines members are valid for all windows in the window
4477 tree. Value is non-zero if they are valid.
4479 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4480 orig_top_line and orig_total_lines for all windows in the tree.
4482 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4483 stored in orig_top_line and orig_total_lines for all windows. */
4486 save_restore_orig_size (struct window
*w
, enum save_restore_action action
)
4492 if (!NILP (w
->hchild
))
4494 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4497 else if (!NILP (w
->vchild
))
4499 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4505 case CHECK_ORIG_SIZES
:
4506 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4510 case SAVE_ORIG_SIZES
:
4511 w
->orig_top_line
= w
->top_line
;
4512 w
->orig_total_lines
= w
->total_lines
;
4513 XSETFASTINT (w
->last_modified
, 0);
4514 XSETFASTINT (w
->last_overlay_modified
, 0);
4517 case RESTORE_ORIG_SIZES
:
4518 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4519 w
->top_line
= w
->orig_top_line
;
4520 w
->total_lines
= w
->orig_total_lines
;
4521 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4522 XSETFASTINT (w
->last_modified
, 0);
4523 XSETFASTINT (w
->last_overlay_modified
, 0);
4530 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4537 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4538 without deleting other windows. */
4541 grow_mini_window (struct window
*w
, int delta
)
4543 struct frame
*f
= XFRAME (w
->frame
);
4544 struct window
*root
;
4546 xassert (MINI_WINDOW_P (w
));
4547 /* Commenting out the following assertion goes against the stated interface
4548 of the function, but it currently does not seem to do anything useful.
4549 See discussion of this issue in the thread for bug#4534.
4550 xassert (delta >= 0); */
4552 /* Compute how much we can enlarge the mini-window without deleting
4554 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4557 int min_height
= window_min_size (root
, 0, 0, 0, 0);
4558 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4559 /* Note that the root window may already be smaller than
4561 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4566 /* Save original window sizes and positions, if not already done. */
4567 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4568 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4570 /* Shrink other windows. */
4571 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4573 /* Grow the mini-window. */
4574 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4575 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4576 XSETFASTINT (w
->last_modified
, 0);
4577 XSETFASTINT (w
->last_overlay_modified
, 0);
4584 /* Shrink mini-window W. If there is recorded info about window sizes
4585 before a call to grow_mini_window, restore recorded window sizes.
4586 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4590 shrink_mini_window (struct window
*w
)
4592 struct frame
*f
= XFRAME (w
->frame
);
4593 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4595 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4597 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4599 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4600 windows_or_buffers_changed
= 1;
4602 else if (XFASTINT (w
->total_lines
) > 1)
4604 /* Distribute the additional lines of the mini-window
4605 among the other windows. */
4607 XSETWINDOW (window
, w
);
4608 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4614 /* Mark window cursors off for all windows in the window tree rooted
4615 at W by setting their phys_cursor_on_p flag to zero. Called from
4616 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4617 the frame are cleared. */
4620 mark_window_cursors_off (struct window
*w
)
4624 if (!NILP (w
->hchild
))
4625 mark_window_cursors_off (XWINDOW (w
->hchild
));
4626 else if (!NILP (w
->vchild
))
4627 mark_window_cursors_off (XWINDOW (w
->vchild
));
4629 w
->phys_cursor_on_p
= 0;
4631 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4636 /* Return number of lines of text (not counting mode lines) in W. */
4639 window_internal_height (struct window
*w
)
4641 int ht
= XFASTINT (w
->total_lines
);
4643 if (!MINI_WINDOW_P (w
))
4645 if (!NILP (w
->parent
)
4646 || !NILP (w
->vchild
)
4647 || !NILP (w
->hchild
)
4650 || WINDOW_WANTS_MODELINE_P (w
))
4653 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4661 /* Return the number of columns in W.
4662 Don't count columns occupied by scroll bars or the vertical bar
4663 separating W from the sibling to its right. */
4666 window_box_text_cols (struct window
*w
)
4668 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4669 int width
= XINT (w
->total_cols
);
4671 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4672 /* Scroll bars occupy a few columns. */
4673 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4674 else if (!FRAME_WINDOW_P (f
)
4675 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4676 /* The column of `|' characters separating side-by-side windows
4677 occupies one column only. */
4680 if (FRAME_WINDOW_P (f
))
4681 /* On window-systems, fringes and display margins cannot be
4682 used for normal text. */
4683 width
-= (WINDOW_FRINGE_COLS (w
)
4684 + WINDOW_LEFT_MARGIN_COLS (w
)
4685 + WINDOW_RIGHT_MARGIN_COLS (w
));
4691 /************************************************************************
4693 ***********************************************************************/
4695 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4696 N screen-fulls, which is defined as the height of the window minus
4697 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4698 instead. Negative values of N mean scroll down. NOERROR non-zero
4699 means don't signal an error if we try to move over BEGV or ZV,
4703 window_scroll (Lisp_Object window
, int n
, int whole
, int noerror
)
4707 /* If we must, use the pixel-based version which is much slower than
4708 the line-based one but can handle varying line heights. */
4709 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4710 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4712 window_scroll_line_based (window
, n
, whole
, noerror
);
4718 /* Implementation of window_scroll that works based on pixel line
4719 heights. See the comment of window_scroll for parameter
4723 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4726 struct window
*w
= XWINDOW (window
);
4727 struct text_pos start
;
4728 int this_scroll_margin
;
4729 /* True if we fiddled the window vscroll field without really scrolling. */
4731 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4733 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4735 /* If PT is not visible in WINDOW, move back one half of
4736 the screen. Allow PT to be partially visible, otherwise
4737 something like (scroll-down 1) with PT in the line before
4738 the partially visible one would recenter. */
4740 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4742 /* Move backward half the height of the window. Performance note:
4743 vmotion used here is about 10% faster, but would give wrong
4744 results for variable height lines. */
4745 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4746 it
.current_y
= it
.last_visible_y
;
4747 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4749 /* The function move_iterator_vertically may move over more than
4750 the specified y-distance. If it->w is small, e.g. a
4751 mini-buffer window, we may end up in front of the window's
4752 display area. This is the case when Start displaying at the
4753 start of the line containing PT in this case. */
4754 if (it
.current_y
<= 0)
4756 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4757 move_it_vertically_backward (&it
, 0);
4761 start
= it
.current
.pos
;
4763 else if (auto_window_vscroll_p
)
4765 if (rtop
|| rbot
) /* partially visible */
4768 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4770 dy
= max ((window_box_height (w
)
4771 - next_screen_context_lines
* dy
),
4777 /* Only vscroll backwards if already vscrolled forwards. */
4778 if (w
->vscroll
< 0 && rtop
> 0)
4780 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4781 Fset_window_vscroll (window
, make_number (px
), Qt
);
4787 /* Do vscroll if already vscrolled or only display line. */
4788 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4790 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4791 Fset_window_vscroll (window
, make_number (px
), Qt
);
4795 /* Maybe modify window start instead of scrolling. */
4796 if (rbot
> 0 || w
->vscroll
< 0)
4800 Fset_window_vscroll (window
, make_number (0), Qt
);
4801 /* If there are other text lines above the current row,
4802 move window start to current row. Else to next row. */
4804 spos
= XINT (Fline_beginning_position (Qnil
));
4806 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4807 set_marker_restricted (w
->start
, make_number (spos
),
4809 w
->start_at_line_beg
= Qt
;
4810 w
->update_mode_line
= Qt
;
4811 XSETFASTINT (w
->last_modified
, 0);
4812 XSETFASTINT (w
->last_overlay_modified
, 0);
4813 /* Set force_start so that redisplay_window will run the
4814 window-scroll-functions. */
4815 w
->force_start
= Qt
;
4820 /* Cancel previous vscroll. */
4821 Fset_window_vscroll (window
, make_number (0), Qt
);
4824 /* If scroll_preserve_screen_position is non-nil, we try to set
4825 point in the same window line as it is now, so get that line. */
4826 if (!NILP (Vscroll_preserve_screen_position
))
4828 /* We preserve the goal pixel coordinate across consecutive
4829 calls to scroll-up, scroll-down and other commands that
4830 have the `scroll-command' property. This avoids the
4831 possibility of point becoming "stuck" on a tall line when
4832 scrolling by one line. */
4833 if (window_scroll_pixel_based_preserve_y
< 0
4834 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4835 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4837 start_display (&it
, w
, start
);
4838 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4839 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4840 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4844 window_scroll_pixel_based_preserve_y
4845 = window_scroll_pixel_based_preserve_x
= -1;
4847 /* Move iterator it from start the specified distance forward or
4848 backward. The result is the new window start. */
4849 start_display (&it
, w
, start
);
4852 EMACS_INT start_pos
= IT_CHARPOS (it
);
4853 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4854 dy
= max ((window_box_height (w
)
4855 - next_screen_context_lines
* dy
),
4858 /* Note that move_it_vertically always moves the iterator to the
4859 start of a line. So, if the last line doesn't have a newline,
4860 we would end up at the start of the line ending at ZV. */
4863 move_it_vertically_backward (&it
, -dy
);
4864 /* Ensure we actually do move, e.g. in case we are currently
4865 looking at an image that is taller that the window height. */
4866 while (start_pos
== IT_CHARPOS (it
)
4867 && start_pos
> BEGV
)
4868 move_it_by_lines (&it
, -1);
4872 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4873 MOVE_TO_POS
| MOVE_TO_Y
);
4874 /* Ensure we actually do move, e.g. in case we are currently
4875 looking at an image that is taller that the window height. */
4876 while (start_pos
== IT_CHARPOS (it
)
4878 move_it_by_lines (&it
, 1);
4882 move_it_by_lines (&it
, n
);
4884 /* We failed if we find ZV is already on the screen (scrolling up,
4885 means there's nothing past the end), or if we can't start any
4886 earlier (scrolling down, means there's nothing past the top). */
4887 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4888 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4890 if (IT_CHARPOS (it
) == ZV
)
4892 if (it
.current_y
< it
.last_visible_y
4893 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4894 > it
.last_visible_y
))
4896 /* The last line was only partially visible, make it fully
4898 w
->vscroll
= (it
.last_visible_y
4899 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4900 adjust_glyphs (it
.f
);
4904 else if (n
< 0) /* could happen with empty buffers */
4905 xsignal0 (Qbeginning_of_buffer
);
4907 xsignal0 (Qend_of_buffer
);
4911 if (w
->vscroll
!= 0)
4912 /* The first line was only partially visible, make it fully
4918 xsignal0 (Qbeginning_of_buffer
);
4921 /* If control gets here, then we vscrolled. */
4923 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4925 /* Don't try to change the window start below. */
4931 EMACS_INT pos
= IT_CHARPOS (it
);
4934 /* If in the middle of a multi-glyph character move forward to
4935 the next character. */
4936 if (in_display_vector_p (&it
))
4939 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4942 /* Set the window start, and set up the window for redisplay. */
4943 set_marker_restricted (w
->start
, make_number (pos
),
4945 bytepos
= XMARKER (w
->start
)->bytepos
;
4946 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4948 w
->update_mode_line
= Qt
;
4949 XSETFASTINT (w
->last_modified
, 0);
4950 XSETFASTINT (w
->last_overlay_modified
, 0);
4951 /* Set force_start so that redisplay_window will run the
4952 window-scroll-functions. */
4953 w
->force_start
= Qt
;
4956 /* The rest of this function uses current_y in a nonstandard way,
4957 not including the height of the header line if any. */
4958 it
.current_y
= it
.vpos
= 0;
4960 /* Move PT out of scroll margins.
4961 This code wants current_y to be zero at the window start position
4962 even if there is a header line. */
4963 this_scroll_margin
= max (0, scroll_margin
);
4964 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4965 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4969 /* We moved the window start towards ZV, so PT may be now
4970 in the scroll margin at the top. */
4971 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4972 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4973 && (NILP (Vscroll_preserve_screen_position
)
4974 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4975 /* We found PT at a legitimate height. Leave it alone. */
4977 else if (window_scroll_pixel_based_preserve_y
>= 0)
4979 /* If we have a header line, take account of it.
4980 This is necessary because we set it.current_y to 0, above. */
4981 move_it_to (&it
, -1,
4982 window_scroll_pixel_based_preserve_x
,
4983 window_scroll_pixel_based_preserve_y
4984 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4985 -1, MOVE_TO_Y
| MOVE_TO_X
);
4986 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4990 while (it
.current_y
< this_scroll_margin
)
4992 int prev
= it
.current_y
;
4993 move_it_by_lines (&it
, 1);
4994 if (prev
== it
.current_y
)
4997 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5002 EMACS_INT charpos
, bytepos
;
5005 /* Save our position, for the
5006 window_scroll_pixel_based_preserve_y case. */
5007 charpos
= IT_CHARPOS (it
);
5008 bytepos
= IT_BYTEPOS (it
);
5010 /* We moved the window start towards BEGV, so PT may be now
5011 in the scroll margin at the bottom. */
5012 move_it_to (&it
, PT
, -1,
5013 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5014 - this_scroll_margin
- 1),
5016 MOVE_TO_POS
| MOVE_TO_Y
);
5018 /* Save our position, in case it's correct. */
5019 charpos
= IT_CHARPOS (it
);
5020 bytepos
= IT_BYTEPOS (it
);
5022 /* See if point is on a partially visible line at the end. */
5023 if (it
.what
== IT_EOB
)
5024 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5027 move_it_by_lines (&it
, 1);
5028 partial_p
= it
.current_y
> it
.last_visible_y
;
5031 if (charpos
== PT
&& !partial_p
5032 && (NILP (Vscroll_preserve_screen_position
)
5033 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5034 /* We found PT before we found the display margin, so PT is ok. */
5036 else if (window_scroll_pixel_based_preserve_y
>= 0)
5038 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5039 start_display (&it
, w
, start
);
5040 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5041 here because we called start_display again and did not
5042 alter it.current_y this time. */
5043 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
5044 window_scroll_pixel_based_preserve_y
, -1,
5045 MOVE_TO_Y
| MOVE_TO_X
);
5046 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5051 /* The last line was only partially visible, so back up two
5052 lines to make sure we're on a fully visible line. */
5054 move_it_by_lines (&it
, -2);
5055 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5058 /* No, the position we saved is OK, so use it. */
5059 SET_PT_BOTH (charpos
, bytepos
);
5065 /* Implementation of window_scroll that works based on screen lines.
5066 See the comment of window_scroll for parameter descriptions. */
5069 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
5071 register struct window
*w
= XWINDOW (window
);
5072 register EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
5073 register EMACS_INT pos
, pos_byte
;
5074 register int ht
= window_internal_height (w
);
5075 register Lisp_Object tem
;
5079 Lisp_Object original_pos
= Qnil
;
5081 /* If scrolling screen-fulls, compute the number of lines to
5082 scroll from the window's height. */
5084 n
*= max (1, ht
- next_screen_context_lines
);
5086 startpos
= marker_position (w
->start
);
5088 if (!NILP (Vscroll_preserve_screen_position
))
5090 if (window_scroll_preserve_vpos
<= 0
5091 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
5092 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
5094 struct position posit
5095 = *compute_motion (startpos
, 0, 0, 0,
5097 -1, XINT (w
->hscroll
),
5099 window_scroll_preserve_vpos
= posit
.vpos
;
5100 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
5103 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
5104 make_number (window_scroll_preserve_vpos
));
5107 XSETFASTINT (tem
, PT
);
5108 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5112 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5117 lose
= n
< 0 && PT
== BEGV
;
5118 Fvertical_motion (make_number (n
), window
);
5122 SET_PT_BOTH (opoint
, opoint_byte
);
5129 xsignal0 (Qbeginning_of_buffer
);
5134 int this_scroll_margin
= scroll_margin
;
5136 /* Don't use a scroll margin that is negative or too large. */
5137 if (this_scroll_margin
< 0)
5138 this_scroll_margin
= 0;
5140 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5141 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5143 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5144 w
->start_at_line_beg
= bolp
;
5145 w
->update_mode_line
= Qt
;
5146 XSETFASTINT (w
->last_modified
, 0);
5147 XSETFASTINT (w
->last_overlay_modified
, 0);
5148 /* Set force_start so that redisplay_window will run
5149 the window-scroll-functions. */
5150 w
->force_start
= Qt
;
5152 if (!NILP (Vscroll_preserve_screen_position
)
5153 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5155 SET_PT_BOTH (pos
, pos_byte
);
5156 Fvertical_motion (original_pos
, window
);
5158 /* If we scrolled forward, put point enough lines down
5159 that it is outside the scroll margin. */
5164 if (this_scroll_margin
> 0)
5166 SET_PT_BOTH (pos
, pos_byte
);
5167 Fvertical_motion (make_number (this_scroll_margin
), window
);
5173 if (top_margin
<= opoint
)
5174 SET_PT_BOTH (opoint
, opoint_byte
);
5175 else if (!NILP (Vscroll_preserve_screen_position
))
5177 SET_PT_BOTH (pos
, pos_byte
);
5178 Fvertical_motion (original_pos
, window
);
5181 SET_PT (top_margin
);
5187 /* If we scrolled backward, put point near the end of the window
5188 but not within the scroll margin. */
5189 SET_PT_BOTH (pos
, pos_byte
);
5190 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5191 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5194 bottom_margin
= PT
+ 1;
5196 if (bottom_margin
> opoint
)
5197 SET_PT_BOTH (opoint
, opoint_byte
);
5200 if (!NILP (Vscroll_preserve_screen_position
))
5202 SET_PT_BOTH (pos
, pos_byte
);
5203 Fvertical_motion (original_pos
, window
);
5206 Fvertical_motion (make_number (-1), window
);
5215 xsignal0 (Qend_of_buffer
);
5220 /* Scroll selected_window up or down. If N is nil, scroll a
5221 screen-full which is defined as the height of the window minus
5222 next_screen_context_lines. If N is the symbol `-', scroll.
5223 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5224 up. This is the guts of Fscroll_up and Fscroll_down. */
5227 scroll_command (Lisp_Object n
, int direction
)
5229 int count
= SPECPDL_INDEX ();
5231 xassert (eabs (direction
) == 1);
5233 /* If selected window's buffer isn't current, make it current for
5234 the moment. But don't screw up if window_scroll gets an error. */
5235 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5237 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5238 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5240 /* Make redisplay consider other windows than just selected_window. */
5241 ++windows_or_buffers_changed
;
5245 window_scroll (selected_window
, direction
, 1, 0);
5246 else if (EQ (n
, Qminus
))
5247 window_scroll (selected_window
, -direction
, 1, 0);
5250 n
= Fprefix_numeric_value (n
);
5251 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5254 unbind_to (count
, Qnil
);
5257 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
5258 doc
: /* Scroll text of selected window upward ARG lines.
5259 If ARG is omitted or nil, scroll upward by a near full screen.
5260 A near full screen is `next-screen-context-lines' less than a full screen.
5261 Negative ARG means scroll downward.
5262 If ARG is the atom `-', scroll downward by nearly full screen.
5263 When calling from a program, supply as argument a number, nil, or `-'. */)
5266 scroll_command (arg
, 1);
5270 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
5271 doc
: /* Scroll text of selected window down ARG lines.
5272 If ARG is omitted or nil, scroll down by a near full screen.
5273 A near full screen is `next-screen-context-lines' less than a full screen.
5274 Negative ARG means scroll upward.
5275 If ARG is the atom `-', scroll upward by nearly full screen.
5276 When calling from a program, supply as argument a number, nil, or `-'. */)
5279 scroll_command (arg
, -1);
5283 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5284 doc
: /* Return the other window for \"other window scroll\" commands.
5285 If `other-window-scroll-buffer' is non-nil, a window
5286 showing that buffer is used.
5287 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5288 specifies the window. This takes precedence over
5289 `other-window-scroll-buffer'. */)
5294 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5295 && !NILP (Vminibuf_scroll_window
))
5296 window
= Vminibuf_scroll_window
;
5297 /* If buffer is specified, scroll that buffer. */
5298 else if (!NILP (Vother_window_scroll_buffer
))
5300 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5302 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5306 /* Nothing specified; look for a neighboring window on the same
5308 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5310 if (EQ (window
, selected_window
))
5311 /* That didn't get us anywhere; look for a window on another
5314 window
= Fnext_window (window
, Qnil
, Qt
);
5315 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5316 && ! EQ (window
, selected_window
));
5319 CHECK_LIVE_WINDOW (window
);
5321 if (EQ (window
, selected_window
))
5322 error ("There is no other window");
5327 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5328 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5329 A near full screen is `next-screen-context-lines' less than a full screen.
5330 The next window is the one below the current one; or the one at the top
5331 if the current one is at the bottom. Negative ARG means scroll downward.
5332 If ARG is the atom `-', scroll downward by nearly full screen.
5333 When calling from a program, supply as argument a number, nil, or `-'.
5335 If `other-window-scroll-buffer' is non-nil, scroll the window
5336 showing that buffer, popping the buffer up if necessary.
5337 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5338 specifies the window to scroll. This takes precedence over
5339 `other-window-scroll-buffer'. */)
5344 int count
= SPECPDL_INDEX ();
5346 window
= Fother_window_for_scrolling ();
5347 w
= XWINDOW (window
);
5349 /* Don't screw up if window_scroll gets an error. */
5350 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5351 ++windows_or_buffers_changed
;
5353 Fset_buffer (w
->buffer
);
5354 SET_PT (marker_position (w
->pointm
));
5357 window_scroll (window
, 1, 1, 1);
5358 else if (EQ (arg
, Qminus
))
5359 window_scroll (window
, -1, 1, 1);
5365 window_scroll (window
, XINT (arg
), 0, 1);
5368 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5369 unbind_to (count
, Qnil
);
5374 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5375 doc
: /* Scroll selected window display ARG columns left.
5376 Default for ARG is window width minus 2.
5377 Value is the total amount of leftward horizontal scrolling in
5378 effect after the change.
5379 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5380 lower bound for automatic scrolling, i.e. automatic scrolling
5381 will not scroll a window to a column less than the value returned
5382 by this function. This happens in an interactive call. */)
5383 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5387 struct window
*w
= XWINDOW (selected_window
);
5390 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5392 arg
= Fprefix_numeric_value (arg
);
5394 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5395 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5397 if (!NILP (set_minimum
))
5398 w
->min_hscroll
= w
->hscroll
;
5403 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5404 doc
: /* Scroll selected window display ARG columns right.
5405 Default for ARG is window width minus 2.
5406 Value is the total amount of leftward horizontal scrolling in
5407 effect after the change.
5408 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5409 lower bound for automatic scrolling, i.e. automatic scrolling
5410 will not scroll a window to a column less than the value returned
5411 by this function. This happens in an interactive call. */)
5412 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5416 struct window
*w
= XWINDOW (selected_window
);
5419 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5421 arg
= Fprefix_numeric_value (arg
);
5423 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5424 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5426 if (!NILP (set_minimum
))
5427 w
->min_hscroll
= w
->hscroll
;
5432 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5433 doc
: /* Return the window which was selected when entering the minibuffer.
5434 Returns nil, if selected window is not a minibuffer window. */)
5437 if (minibuf_level
> 0
5438 && MINI_WINDOW_P (XWINDOW (selected_window
))
5439 && WINDOW_LIVE_P (minibuf_selected_window
))
5440 return minibuf_selected_window
;
5445 /* Value is the number of lines actually displayed in window W,
5446 as opposed to its height. */
5449 displayed_window_lines (struct window
*w
)
5452 struct text_pos start
;
5453 int height
= window_box_height (w
);
5454 struct buffer
*old_buffer
;
5457 if (XBUFFER (w
->buffer
) != current_buffer
)
5459 old_buffer
= current_buffer
;
5460 set_buffer_internal (XBUFFER (w
->buffer
));
5465 /* In case W->start is out of the accessible range, do something
5466 reasonable. This happens in Info mode when Info-scroll-down
5467 calls (recenter -1) while W->start is 1. */
5468 if (XMARKER (w
->start
)->charpos
< BEGV
)
5469 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5470 else if (XMARKER (w
->start
)->charpos
> ZV
)
5471 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5473 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5475 start_display (&it
, w
, start
);
5476 move_it_vertically (&it
, height
);
5477 bottom_y
= line_bottom_y (&it
);
5479 /* rms: On a non-window display,
5480 the value of it.vpos at the bottom of the screen
5481 seems to be 1 larger than window_box_height (w).
5482 This kludge fixes a bug whereby (move-to-window-line -1)
5483 when ZV is on the last screen line
5484 moves to the previous screen line instead of the last one. */
5485 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5488 /* Add in empty lines at the bottom of the window. */
5489 if (bottom_y
< height
)
5491 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5492 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5496 set_buffer_internal (old_buffer
);
5502 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5503 doc
: /* Center point in selected window and maybe redisplay frame.
5504 With prefix argument ARG, recenter putting point on screen line ARG
5505 relative to the selected window. If ARG is negative, it counts up from the
5506 bottom of the window. (ARG should be less than the height of the window.)
5508 If ARG is omitted or nil, then recenter with point on the middle line of
5509 the selected window; if the variable `recenter-redisplay' is non-nil,
5510 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5511 is set to `grow-only', this resets the tool-bar's height to the minimum
5512 height needed); if `recenter-redisplay' has the special value `tty',
5513 then only tty frame are redrawn.
5515 Just C-u as prefix means put point in the center of the window
5516 and redisplay normally--don't erase and redraw the frame. */)
5517 (register Lisp_Object arg
)
5519 struct window
*w
= XWINDOW (selected_window
);
5520 struct buffer
*buf
= XBUFFER (w
->buffer
);
5521 struct buffer
*obuf
= current_buffer
;
5523 EMACS_INT charpos
, bytepos
;
5524 int iarg
IF_LINT (= 0);
5525 int this_scroll_margin
;
5527 /* If redisplay is suppressed due to an error, try again. */
5528 obuf
->display_error_modiff
= 0;
5532 if (!NILP (Vrecenter_redisplay
)
5533 && (!EQ (Vrecenter_redisplay
, Qtty
)
5534 || !NILP (Ftty_type (selected_frame
))))
5538 /* Invalidate pixel data calculated for all compositions. */
5539 for (i
= 0; i
< n_compositions
; i
++)
5540 composition_table
[i
]->font
= NULL
;
5542 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5544 Fredraw_frame (WINDOW_FRAME (w
));
5545 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5550 else if (CONSP (arg
)) /* Just C-u. */
5554 arg
= Fprefix_numeric_value (arg
);
5559 set_buffer_internal (buf
);
5561 /* Do this after making BUF current
5562 in case scroll_margin is buffer-local. */
5563 this_scroll_margin
= max (0, scroll_margin
);
5564 this_scroll_margin
= min (this_scroll_margin
,
5565 XFASTINT (w
->total_lines
) / 4);
5567 /* Handle centering on a graphical frame specially. Such frames can
5568 have variable-height lines and centering point on the basis of
5569 line counts would lead to strange effects. */
5570 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5577 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5578 start_display (&it
, w
, pt
);
5579 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5580 charpos
= IT_CHARPOS (it
);
5581 bytepos
= IT_BYTEPOS (it
);
5588 int extra_line_spacing
;
5589 int h
= window_box_height (w
);
5591 iarg
= - max (-iarg
, this_scroll_margin
);
5593 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5594 start_display (&it
, w
, pt
);
5596 /* Be sure we have the exact height of the full line containing PT. */
5597 move_it_by_lines (&it
, 0);
5599 /* The amount of pixels we have to move back is the window
5600 height minus what's displayed in the line containing PT,
5601 and the lines below. */
5604 move_it_by_lines (&it
, nlines
);
5606 if (it
.vpos
== nlines
)
5610 /* Last line has no newline */
5611 h
-= line_bottom_y (&it
);
5615 /* Don't reserve space for extra line spacing of last line. */
5616 extra_line_spacing
= it
.max_extra_line_spacing
;
5618 /* If we can't move down NLINES lines because we hit
5619 the end of the buffer, count in some empty lines. */
5620 if (it
.vpos
< nlines
)
5623 extra_line_spacing
= it
.extra_line_spacing
;
5624 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5629 /* Now find the new top line (starting position) of the window. */
5630 start_display (&it
, w
, pt
);
5632 move_it_vertically_backward (&it
, h
);
5634 /* If extra line spacing is present, we may move too far
5635 back. This causes the last line to be only partially
5636 visible (which triggers redisplay to recenter that line
5637 in the middle), so move forward.
5638 But ignore extra line spacing on last line, as it is not
5639 considered to be part of the visible height of the line.
5641 h
+= extra_line_spacing
;
5642 while (-it
.current_y
> h
)
5643 move_it_by_lines (&it
, 1);
5645 charpos
= IT_CHARPOS (it
);
5646 bytepos
= IT_BYTEPOS (it
);
5650 struct position pos
;
5652 iarg
= max (iarg
, this_scroll_margin
);
5654 pos
= *vmotion (PT
, -iarg
, w
);
5655 charpos
= pos
.bufpos
;
5656 bytepos
= pos
.bytepos
;
5661 struct position pos
;
5662 int ht
= window_internal_height (w
);
5669 /* Don't let it get into the margin at either top or bottom. */
5670 iarg
= max (iarg
, this_scroll_margin
);
5671 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5673 pos
= *vmotion (PT
, - iarg
, w
);
5674 charpos
= pos
.bufpos
;
5675 bytepos
= pos
.bytepos
;
5678 /* Set the new window start. */
5679 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5680 w
->window_end_valid
= Qnil
;
5682 w
->optional_new_start
= Qt
;
5684 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5685 w
->start_at_line_beg
= Qt
;
5687 w
->start_at_line_beg
= Qnil
;
5689 set_buffer_internal (obuf
);
5694 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5696 doc
: /* Return the height in lines of the text display area of WINDOW.
5697 WINDOW defaults to the selected window.
5699 The return value does not include the mode line, any header line, nor
5700 any partial-height lines in the text display area. */)
5701 (Lisp_Object window
)
5703 struct window
*w
= decode_window (window
);
5704 int pixel_height
= window_box_height (w
);
5705 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5706 return make_number (line_height
);
5711 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5713 doc
: /* Position point relative to window.
5714 With no argument, position point at center of window.
5715 An argument specifies vertical position within the window;
5716 zero means top of window, negative means relative to bottom of window. */)
5719 struct window
*w
= XWINDOW (selected_window
);
5723 int this_scroll_margin
;
5726 if (!(BUFFERP (w
->buffer
)
5727 && XBUFFER (w
->buffer
) == current_buffer
))
5728 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5729 when passed below to set_marker_both. */
5730 error ("move-to-window-line called from unrelated buffer");
5732 window
= selected_window
;
5733 start
= marker_position (w
->start
);
5734 if (start
< BEGV
|| start
> ZV
)
5736 int height
= window_internal_height (w
);
5737 Fvertical_motion (make_number (- (height
/ 2)), window
);
5738 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5739 w
->start_at_line_beg
= Fbolp ();
5740 w
->force_start
= Qt
;
5743 Fgoto_char (w
->start
);
5745 lines
= displayed_window_lines (w
);
5748 this_scroll_margin
= max (0, scroll_margin
);
5749 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5753 XSETFASTINT (arg
, lines
/ 2);
5756 int iarg
= XINT (Fprefix_numeric_value (arg
));
5759 iarg
= iarg
+ lines
;
5761 #if 0 /* This code would prevent move-to-window-line from moving point
5762 to a place inside the scroll margins (which would cause the
5763 next redisplay to scroll). I wrote this code, but then concluded
5764 it is probably better not to install it. However, it is here
5765 inside #if 0 so as not to lose it. -- rms. */
5767 /* Don't let it get into the margin at either top or bottom. */
5768 iarg
= max (iarg
, this_scroll_margin
);
5769 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5772 arg
= make_number (iarg
);
5775 /* Skip past a partially visible first line. */
5777 XSETINT (arg
, XINT (arg
) + 1);
5779 return Fvertical_motion (arg
, window
);
5784 /***********************************************************************
5785 Window Configuration
5786 ***********************************************************************/
5788 struct save_window_data
5791 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5792 Lisp_Object selected_frame
;
5793 Lisp_Object current_window
;
5794 Lisp_Object current_buffer
;
5795 Lisp_Object minibuf_scroll_window
;
5796 Lisp_Object minibuf_selected_window
;
5797 Lisp_Object root_window
;
5798 Lisp_Object focus_frame
;
5799 /* A vector, each of whose elements is a struct saved_window
5801 Lisp_Object saved_windows
;
5803 /* All fields above are traced by the GC.
5804 From `fame-cols' down, the fields are ignored by the GC. */
5806 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5807 int frame_tool_bar_lines
;
5810 /* This is saved as a Lisp_Vector */
5813 /* these first two must agree with struct Lisp_Vector in lisp.h */
5815 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5818 Lisp_Object buffer
, start
, pointm
, mark
;
5819 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5820 Lisp_Object hscroll
, min_hscroll
;
5821 Lisp_Object parent
, prev
;
5822 Lisp_Object start_at_line_beg
;
5823 Lisp_Object display_table
;
5824 Lisp_Object orig_top_line
, orig_total_lines
;
5825 Lisp_Object left_margin_cols
, right_margin_cols
;
5826 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5827 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5828 Lisp_Object dedicated
, resize_proportionally
;
5831 #define SAVED_WINDOW_N(swv,n) \
5832 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5834 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5835 doc
: /* Return t if OBJECT is a window-configuration object. */)
5836 (Lisp_Object object
)
5838 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5841 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5842 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5843 (Lisp_Object config
)
5845 register struct save_window_data
*data
;
5846 struct Lisp_Vector
*saved_windows
;
5848 CHECK_WINDOW_CONFIGURATION (config
);
5850 data
= (struct save_window_data
*) XVECTOR (config
);
5851 saved_windows
= XVECTOR (data
->saved_windows
);
5852 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5855 DEFUN ("set-window-configuration", Fset_window_configuration
,
5856 Sset_window_configuration
, 1, 1, 0,
5857 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5858 CONFIGURATION must be a value previously returned
5859 by `current-window-configuration' (which see).
5860 If CONFIGURATION was made from a frame that is now deleted,
5861 only frame-independent values can be restored. In this case,
5862 the return value is nil. Otherwise the value is t. */)
5863 (Lisp_Object configuration
)
5865 register struct save_window_data
*data
;
5866 struct Lisp_Vector
*saved_windows
;
5867 Lisp_Object new_current_buffer
;
5870 EMACS_INT old_point
= -1;
5872 CHECK_WINDOW_CONFIGURATION (configuration
);
5874 data
= (struct save_window_data
*) XVECTOR (configuration
);
5875 saved_windows
= XVECTOR (data
->saved_windows
);
5877 new_current_buffer
= data
->current_buffer
;
5878 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5879 new_current_buffer
= Qnil
;
5882 if (XBUFFER (new_current_buffer
) == current_buffer
)
5883 /* The code further down "preserves point" by saving here PT in
5884 old_point and then setting it later back into PT. When the
5885 current-selected-window and the final-selected-window both show
5886 the current buffer, this suffers from the problem that the
5887 current PT is the window-point of the current-selected-window,
5888 while the final PT is the point of the final-selected-window, so
5889 this copy from one PT to the other would end up moving the
5890 window-point of the final-selected-window to the window-point of
5891 the current-selected-window. So we have to be careful which
5892 point of the current-buffer we copy into old_point. */
5893 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5894 && WINDOWP (selected_window
)
5895 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5896 && !EQ (selected_window
, data
->current_window
))
5897 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5901 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5902 point in new_current_buffer as of the last time this buffer was
5903 used. This can be non-deterministic since it can be changed by
5904 things like jit-lock by mere temporary selection of some random
5905 window that happens to show this buffer.
5906 So if possible we want this arbitrary choice of "which point" to
5907 be the one from the to-be-selected-window so as to prevent this
5908 window's cursor from being copied from another window. */
5909 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5910 /* If current_window = selected_window, its point is in BUF_PT. */
5911 && !EQ (selected_window
, data
->current_window
))
5912 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5914 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5917 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5920 /* If f is a dead frame, don't bother rebuilding its window tree.
5921 However, there is other stuff we should still try to do below. */
5922 if (FRAME_LIVE_P (f
))
5924 register struct window
*w
;
5925 register struct saved_window
*p
;
5926 struct window
*root_window
;
5927 struct window
**leaf_windows
;
5931 /* If the frame has been resized since this window configuration was
5932 made, we change the frame to the size specified in the
5933 configuration, restore the configuration, and then resize it
5934 back. We keep track of the prevailing height in these variables. */
5935 int previous_frame_lines
= FRAME_LINES (f
);
5936 int previous_frame_cols
= FRAME_COLS (f
);
5937 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5938 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5940 /* The mouse highlighting code could get screwed up
5941 if it runs during this. */
5944 if (data
->frame_lines
!= previous_frame_lines
5945 || data
->frame_cols
!= previous_frame_cols
)
5946 change_frame_size (f
, data
->frame_lines
,
5947 data
->frame_cols
, 0, 0, 0);
5948 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5949 if (data
->frame_menu_bar_lines
5950 != previous_frame_menu_bar_lines
)
5951 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5953 #ifdef HAVE_WINDOW_SYSTEM
5954 if (data
->frame_tool_bar_lines
5955 != previous_frame_tool_bar_lines
)
5956 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5961 /* "Swap out" point from the selected window's buffer
5962 into the window itself. (Normally the pointm of the selected
5963 window holds garbage.) We do this now, before
5964 restoring the window contents, and prevent it from
5965 being done later on when we select a new window. */
5966 if (! NILP (XWINDOW (selected_window
)->buffer
))
5968 w
= XWINDOW (selected_window
);
5969 set_marker_both (w
->pointm
,
5971 BUF_PT (XBUFFER (w
->buffer
)),
5972 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5975 windows_or_buffers_changed
++;
5976 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5978 /* Problem: Freeing all matrices and later allocating them again
5979 is a serious redisplay flickering problem. What we would
5980 really like to do is to free only those matrices not reused
5982 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5984 = (struct window
**) alloca (count_windows (root_window
)
5985 * sizeof (struct window
*));
5986 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5989 Mark all windows now on frame as "deleted".
5990 Restoring the new configuration "undeletes" any that are in it.
5992 Save their current buffers in their height fields, since we may
5993 need it later, if a buffer saved in the configuration is now
5995 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5997 for (k
= 0; k
< saved_windows
->size
; k
++)
5999 p
= SAVED_WINDOW_N (saved_windows
, k
);
6000 w
= XWINDOW (p
->window
);
6003 if (!NILP (p
->parent
))
6004 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6005 XFASTINT (p
->parent
))->window
;
6009 if (!NILP (p
->prev
))
6011 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6012 XFASTINT (p
->prev
))->window
;
6013 XWINDOW (w
->prev
)->next
= p
->window
;
6018 if (!NILP (w
->parent
))
6020 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6022 XWINDOW (w
->parent
)->vchild
= p
->window
;
6023 XWINDOW (w
->parent
)->hchild
= Qnil
;
6027 XWINDOW (w
->parent
)->hchild
= p
->window
;
6028 XWINDOW (w
->parent
)->vchild
= Qnil
;
6033 /* If we squirreled away the buffer in the window's height,
6035 if (BUFFERP (w
->total_lines
))
6036 w
->buffer
= w
->total_lines
;
6037 w
->left_col
= p
->left_col
;
6038 w
->top_line
= p
->top_line
;
6039 w
->total_cols
= p
->total_cols
;
6040 w
->total_lines
= p
->total_lines
;
6041 w
->hscroll
= p
->hscroll
;
6042 w
->min_hscroll
= p
->min_hscroll
;
6043 w
->display_table
= p
->display_table
;
6044 w
->orig_top_line
= p
->orig_top_line
;
6045 w
->orig_total_lines
= p
->orig_total_lines
;
6046 w
->left_margin_cols
= p
->left_margin_cols
;
6047 w
->right_margin_cols
= p
->right_margin_cols
;
6048 w
->left_fringe_width
= p
->left_fringe_width
;
6049 w
->right_fringe_width
= p
->right_fringe_width
;
6050 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6051 w
->scroll_bar_width
= p
->scroll_bar_width
;
6052 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6053 w
->dedicated
= p
->dedicated
;
6054 w
->resize_proportionally
= p
->resize_proportionally
;
6055 XSETFASTINT (w
->last_modified
, 0);
6056 XSETFASTINT (w
->last_overlay_modified
, 0);
6058 /* Reinstall the saved buffer and pointers into it. */
6059 if (NILP (p
->buffer
))
6060 w
->buffer
= p
->buffer
;
6063 if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
6064 /* If saved buffer is alive, install it. */
6066 w
->buffer
= p
->buffer
;
6067 w
->start_at_line_beg
= p
->start_at_line_beg
;
6068 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6069 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6070 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
6071 p
->mark
, w
->buffer
);
6073 /* As documented in Fcurrent_window_configuration, don't
6074 restore the location of point in the buffer which was
6075 current when the window configuration was recorded. */
6076 if (!EQ (p
->buffer
, new_current_buffer
)
6077 && XBUFFER (p
->buffer
) == current_buffer
)
6078 Fgoto_char (w
->pointm
);
6080 else if (NILP (w
->buffer
) || NILP (BVAR (XBUFFER (w
->buffer
), name
)))
6081 /* Else unless window has a live buffer, get one. */
6083 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6084 /* This will set the markers to beginning of visible
6086 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6087 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6088 w
->start_at_line_beg
= Qt
;
6091 /* Keeping window's old buffer; make sure the markers
6094 /* Set window markers at start of visible range. */
6095 if (XMARKER (w
->start
)->buffer
== 0)
6096 set_marker_restricted (w
->start
, make_number (0),
6098 if (XMARKER (w
->pointm
)->buffer
== 0)
6099 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6100 BUF_PT (XBUFFER (w
->buffer
)),
6101 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6102 w
->start_at_line_beg
= Qt
;
6107 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6109 /* Arrange *not* to restore point in the buffer that was
6110 current when the window configuration was saved. */
6111 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6112 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6113 make_number (old_point
),
6114 XWINDOW (data
->current_window
)->buffer
);
6116 /* In the following call to `select-window, prevent "swapping
6117 out point" in the old selected window using the buffer that
6118 has been restored into it. We already swapped out that point
6119 from that window's old buffer. */
6120 select_window (data
->current_window
, Qnil
, 1);
6121 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
6124 if (NILP (data
->focus_frame
)
6125 || (FRAMEP (data
->focus_frame
)
6126 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6127 Fredirect_frame_focus (frame
, data
->focus_frame
);
6129 /* Set the screen height to the value it had before this function. */
6130 if (previous_frame_lines
!= FRAME_LINES (f
)
6131 || previous_frame_cols
!= FRAME_COLS (f
))
6132 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6134 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6135 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6136 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6138 #ifdef HAVE_WINDOW_SYSTEM
6139 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6140 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6145 /* Now, free glyph matrices in windows that were not reused. */
6146 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6148 if (NILP (leaf_windows
[i
]->buffer
))
6150 /* Assert it's not reused as a combination. */
6151 xassert (NILP (leaf_windows
[i
]->hchild
)
6152 && NILP (leaf_windows
[i
]->vchild
));
6153 free_window_matrices (leaf_windows
[i
]);
6155 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6163 /* Fselect_window will have made f the selected frame, so we
6164 reselect the proper frame here. Fhandle_switch_frame will change the
6165 selected window too, but that doesn't make the call to
6166 Fselect_window above totally superfluous; it still sets f's
6168 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6169 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
6171 run_window_configuration_change_hook (f
);
6174 if (!NILP (new_current_buffer
))
6175 Fset_buffer (new_current_buffer
);
6177 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6178 minibuf_selected_window
= data
->minibuf_selected_window
;
6180 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6183 /* Mark all windows now on frame as deleted
6184 by setting their buffers to nil. */
6187 delete_all_subwindows (register struct window
*w
)
6189 if (!NILP (w
->next
))
6190 delete_all_subwindows (XWINDOW (w
->next
));
6191 if (!NILP (w
->vchild
))
6192 delete_all_subwindows (XWINDOW (w
->vchild
));
6193 if (!NILP (w
->hchild
))
6194 delete_all_subwindows (XWINDOW (w
->hchild
));
6196 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6198 if (!NILP (w
->buffer
))
6201 /* We set all three of these fields to nil, to make sure that we can
6202 distinguish this dead window from any live window. Live leaf
6203 windows will have buffer set, and combination windows will have
6204 vchild or hchild set. */
6209 Vwindow_list
= Qnil
;
6213 count_windows (register struct window
*window
)
6215 register int count
= 1;
6216 if (!NILP (window
->next
))
6217 count
+= count_windows (XWINDOW (window
->next
));
6218 if (!NILP (window
->vchild
))
6219 count
+= count_windows (XWINDOW (window
->vchild
));
6220 if (!NILP (window
->hchild
))
6221 count
+= count_windows (XWINDOW (window
->hchild
));
6226 /* Fill vector FLAT with leaf windows under W, starting at index I.
6227 Value is last index + 1. */
6230 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
6234 if (!NILP (w
->hchild
))
6235 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6236 else if (!NILP (w
->vchild
))
6237 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6241 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6248 /* Return a pointer to the glyph W's physical cursor is on. Value is
6249 null if W's current matrix is invalid, so that no meaningfull glyph
6253 get_phys_cursor_glyph (struct window
*w
)
6255 struct glyph_row
*row
;
6256 struct glyph
*glyph
;
6258 if (w
->phys_cursor
.vpos
>= 0
6259 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6260 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6262 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6263 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6272 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6274 register struct saved_window
*p
;
6275 register struct window
*w
;
6276 register Lisp_Object tem
;
6278 for (;!NILP (window
); window
= w
->next
)
6280 p
= SAVED_WINDOW_N (vector
, i
);
6281 w
= XWINDOW (window
);
6283 XSETFASTINT (w
->temslot
, i
); i
++;
6285 p
->buffer
= w
->buffer
;
6286 p
->left_col
= w
->left_col
;
6287 p
->top_line
= w
->top_line
;
6288 p
->total_cols
= w
->total_cols
;
6289 p
->total_lines
= w
->total_lines
;
6290 p
->hscroll
= w
->hscroll
;
6291 p
->min_hscroll
= w
->min_hscroll
;
6292 p
->display_table
= w
->display_table
;
6293 p
->orig_top_line
= w
->orig_top_line
;
6294 p
->orig_total_lines
= w
->orig_total_lines
;
6295 p
->left_margin_cols
= w
->left_margin_cols
;
6296 p
->right_margin_cols
= w
->right_margin_cols
;
6297 p
->left_fringe_width
= w
->left_fringe_width
;
6298 p
->right_fringe_width
= w
->right_fringe_width
;
6299 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6300 p
->scroll_bar_width
= w
->scroll_bar_width
;
6301 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6302 p
->dedicated
= w
->dedicated
;
6303 p
->resize_proportionally
= w
->resize_proportionally
;
6304 if (!NILP (w
->buffer
))
6306 /* Save w's value of point in the window configuration.
6307 If w is the selected window, then get the value of point
6308 from the buffer; pointm is garbage in the selected window. */
6309 if (EQ (window
, selected_window
))
6311 p
->pointm
= Fmake_marker ();
6312 set_marker_both (p
->pointm
, w
->buffer
,
6313 BUF_PT (XBUFFER (w
->buffer
)),
6314 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6317 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6319 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6320 p
->start_at_line_beg
= w
->start_at_line_beg
;
6322 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6323 p
->mark
= Fcopy_marker (tem
, Qnil
);
6330 p
->start_at_line_beg
= Qnil
;
6333 if (NILP (w
->parent
))
6336 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6341 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6343 if (!NILP (w
->vchild
))
6344 i
= save_window_save (w
->vchild
, vector
, i
);
6345 if (!NILP (w
->hchild
))
6346 i
= save_window_save (w
->hchild
, vector
, i
);
6352 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6353 Scurrent_window_configuration
, 0, 1, 0,
6354 doc
: /* Return an object representing the current window configuration of FRAME.
6355 If FRAME is nil or omitted, use the selected frame.
6356 This describes the number of windows, their sizes and current buffers,
6357 and for each displayed buffer, where display starts, and the positions of
6358 point and mark. An exception is made for point in the current buffer:
6359 its value is -not- saved.
6360 This also records the currently selected frame, and FRAME's focus
6361 redirection (see `redirect-frame-focus'). */)
6364 register Lisp_Object tem
;
6365 register int n_windows
;
6366 register struct save_window_data
*data
;
6371 frame
= selected_frame
;
6372 CHECK_LIVE_FRAME (frame
);
6375 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6376 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6377 PVEC_WINDOW_CONFIGURATION
);
6379 data
->frame_cols
= FRAME_COLS (f
);
6380 data
->frame_lines
= FRAME_LINES (f
);
6381 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6382 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6383 data
->selected_frame
= selected_frame
;
6384 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6385 XSETBUFFER (data
->current_buffer
, current_buffer
);
6386 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6387 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6388 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6389 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6390 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6391 data
->saved_windows
= tem
;
6392 for (i
= 0; i
< n_windows
; i
++)
6393 XVECTOR (tem
)->contents
[i
]
6394 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6395 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6396 XSETWINDOW_CONFIGURATION (tem
, data
);
6401 /***********************************************************************
6403 ***********************************************************************/
6406 window_tree (struct window
*w
)
6408 Lisp_Object tail
= Qnil
;
6409 Lisp_Object result
= Qnil
;
6416 if (!NILP (w
->hchild
))
6417 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6418 window_tree (XWINDOW (w
->hchild
))));
6419 else if (!NILP (w
->vchild
))
6420 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6421 window_tree (XWINDOW (w
->vchild
))));
6425 result
= tail
= Fcons (wn
, Qnil
);
6429 XSETCDR (tail
, Fcons (wn
, Qnil
));
6433 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6441 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6443 doc
: /* Return the window tree for frame FRAME.
6445 The return value is a list of the form (ROOT MINI), where ROOT
6446 represents the window tree of the frame's root window, and MINI
6447 is the frame's minibuffer window.
6449 If the root window is not split, ROOT is the root window itself.
6450 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6451 horizontal split, and t for a vertical split, EDGES gives the combined
6452 size and position of the subwindows in the split, and the rest of the
6453 elements are the subwindows in the split. Each of the subwindows may
6454 again be a window or a list representing a window split, and so on.
6455 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6457 If FRAME is nil or omitted, return information on the currently
6464 frame
= selected_frame
;
6466 CHECK_FRAME (frame
);
6469 if (!FRAME_LIVE_P (f
))
6472 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6476 /***********************************************************************
6478 ***********************************************************************/
6480 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6482 doc
: /* Set width of marginal areas of window WINDOW.
6483 If WINDOW is nil, set margins of the currently selected window.
6484 Second arg LEFT-WIDTH specifies the number of character cells to
6485 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6486 does the same for the right marginal area. A nil width parameter
6487 means no margin. */)
6488 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6490 struct window
*w
= decode_window (window
);
6492 /* Translate negative or zero widths to nil.
6493 Margins that are too wide have to be checked elsewhere. */
6495 if (!NILP (left_width
))
6497 CHECK_NUMBER (left_width
);
6498 if (XINT (left_width
) <= 0)
6502 if (!NILP (right_width
))
6504 CHECK_NUMBER (right_width
);
6505 if (XINT (right_width
) <= 0)
6509 if (!EQ (w
->left_margin_cols
, left_width
)
6510 || !EQ (w
->right_margin_cols
, right_width
))
6512 w
->left_margin_cols
= left_width
;
6513 w
->right_margin_cols
= right_width
;
6515 adjust_window_margins (w
);
6517 ++windows_or_buffers_changed
;
6518 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6525 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6527 doc
: /* Get width of marginal areas of window WINDOW.
6528 If WINDOW is omitted or nil, use the currently selected window.
6529 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6530 If a marginal area does not exist, its width will be returned
6532 (Lisp_Object window
)
6534 struct window
*w
= decode_window (window
);
6535 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6540 /***********************************************************************
6542 ***********************************************************************/
6544 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6546 doc
: /* Set the fringe widths of window WINDOW.
6547 If WINDOW is nil, set the fringe widths of the currently selected
6549 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6550 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6551 fringe width. If a fringe width arg is nil, that means to use the
6552 frame's default fringe width. Default fringe widths can be set with
6553 the command `set-fringe-style'.
6554 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6555 outside of the display margins. By default, fringes are drawn between
6556 display marginal areas and the text area. */)
6557 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6559 struct window
*w
= decode_window (window
);
6561 if (!NILP (left_width
))
6562 CHECK_NATNUM (left_width
);
6563 if (!NILP (right_width
))
6564 CHECK_NATNUM (right_width
);
6566 /* Do nothing on a tty. */
6567 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6568 && (!EQ (w
->left_fringe_width
, left_width
)
6569 || !EQ (w
->right_fringe_width
, right_width
)
6570 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6572 w
->left_fringe_width
= left_width
;
6573 w
->right_fringe_width
= right_width
;
6574 w
->fringes_outside_margins
= outside_margins
;
6576 adjust_window_margins (w
);
6578 clear_glyph_matrix (w
->current_matrix
);
6579 w
->window_end_valid
= Qnil
;
6581 ++windows_or_buffers_changed
;
6582 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6589 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6591 doc
: /* Get width of fringes of window WINDOW.
6592 If WINDOW is omitted or nil, use the currently selected window.
6593 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6594 (Lisp_Object window
)
6596 struct window
*w
= decode_window (window
);
6598 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6599 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6600 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6601 ? Qt
: Qnil
), Qnil
)));
6606 /***********************************************************************
6608 ***********************************************************************/
6610 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6612 doc
: /* Set width and type of scroll bars of window WINDOW.
6613 If window is nil, set scroll bars of the currently selected window.
6614 Second parameter WIDTH specifies the pixel width for the scroll bar;
6615 this is automatically adjusted to a multiple of the frame column width.
6616 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6617 bar: left, right, or nil.
6618 If WIDTH is nil, use the frame's scroll-bar width.
6619 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6620 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6621 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6623 struct window
*w
= decode_window (window
);
6627 CHECK_NATNUM (width
);
6629 if (XINT (width
) == 0)
6630 vertical_type
= Qnil
;
6633 if (!(NILP (vertical_type
)
6634 || EQ (vertical_type
, Qleft
)
6635 || EQ (vertical_type
, Qright
)
6636 || EQ (vertical_type
, Qt
)))
6637 error ("Invalid type of vertical scroll bar");
6639 if (!EQ (w
->scroll_bar_width
, width
)
6640 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6642 w
->scroll_bar_width
= width
;
6643 w
->vertical_scroll_bar_type
= vertical_type
;
6645 adjust_window_margins (w
);
6647 clear_glyph_matrix (w
->current_matrix
);
6648 w
->window_end_valid
= Qnil
;
6650 ++windows_or_buffers_changed
;
6651 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6658 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6660 doc
: /* Get width and type of scroll bars of window WINDOW.
6661 If WINDOW is omitted or nil, use the currently selected window.
6662 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6663 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6665 (Lisp_Object window
)
6667 struct window
*w
= decode_window (window
);
6668 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6669 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6670 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6671 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6672 Fcons (w
->vertical_scroll_bar_type
,
6673 Fcons (Qnil
, Qnil
))));
6678 /***********************************************************************
6680 ***********************************************************************/
6682 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6683 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6684 Use the selected window if WINDOW is nil or omitted.
6685 Normally, value is a multiple of the canonical character height of WINDOW;
6686 optional second arg PIXELS-P means value is measured in pixels. */)
6687 (Lisp_Object window
, Lisp_Object pixels_p
)
6694 window
= selected_window
;
6696 CHECK_WINDOW (window
);
6697 w
= XWINDOW (window
);
6698 f
= XFRAME (w
->frame
);
6700 if (FRAME_WINDOW_P (f
))
6701 result
= (NILP (pixels_p
)
6702 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6703 : make_number (-w
->vscroll
));
6705 result
= make_number (0);
6710 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6712 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6713 WINDOW nil means use the selected window. Normally, VSCROLL is a
6714 non-negative multiple of the canonical character height of WINDOW;
6715 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6716 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6717 corresponds to an integral number of pixels. The return value is the
6718 result of this rounding.
6719 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6720 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6726 window
= selected_window
;
6728 CHECK_WINDOW (window
);
6729 CHECK_NUMBER_OR_FLOAT (vscroll
);
6731 w
= XWINDOW (window
);
6732 f
= XFRAME (w
->frame
);
6734 if (FRAME_WINDOW_P (f
))
6736 int old_dy
= w
->vscroll
;
6738 w
->vscroll
= - (NILP (pixels_p
)
6739 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6740 : XFLOATINT (vscroll
));
6741 w
->vscroll
= min (w
->vscroll
, 0);
6743 if (w
->vscroll
!= old_dy
)
6745 /* Adjust glyph matrix of the frame if the virtual display
6746 area becomes larger than before. */
6747 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6750 /* Prevent redisplay shortcuts. */
6751 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6755 return Fwindow_vscroll (window
, pixels_p
);
6759 /* Call FN for all leaf windows on frame F. FN is called with the
6760 first argument being a pointer to the leaf window, and with
6761 additional argument USER_DATA. Stops when FN returns 0. */
6764 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6767 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6768 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6769 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6773 /* Helper function for foreach_window. Call FN for all leaf windows
6774 reachable from W. FN is called with the first argument being a
6775 pointer to the leaf window, and with additional argument USER_DATA.
6776 Stop when FN returns 0. Value is 0 if stopped by FN. */
6779 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6783 for (cont
= 1; w
&& cont
;)
6785 if (!NILP (w
->hchild
))
6786 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6787 else if (!NILP (w
->vchild
))
6788 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6790 cont
= fn (w
, user_data
);
6792 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6799 /* Freeze or unfreeze the window start of W unless it is a
6800 mini-window or the selected window. FREEZE_P non-null means freeze
6801 the window start. */
6804 freeze_window_start (struct window
*w
, void *freeze_p
)
6806 if (MINI_WINDOW_P (w
)
6807 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6808 && (w
== XWINDOW (selected_window
)
6809 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6810 && ! NILP (Vminibuf_scroll_window
)
6811 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6814 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6819 /* Freeze or unfreeze the window starts of all leaf windows on frame
6820 F, except the selected window and a mini-window. FREEZE_P non-zero
6821 means freeze the window start. */
6824 freeze_window_starts (struct frame
*f
, int freeze_p
)
6826 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6830 /***********************************************************************
6832 ***********************************************************************/
6834 /* Return 1 if window configurations C1 and C2
6835 describe the same state of affairs. This is used by Fequal. */
6838 compare_window_configurations (Lisp_Object c1
, Lisp_Object c2
, int ignore_positions
)
6840 register struct save_window_data
*d1
, *d2
;
6841 struct Lisp_Vector
*sw1
, *sw2
;
6844 CHECK_WINDOW_CONFIGURATION (c1
);
6845 CHECK_WINDOW_CONFIGURATION (c2
);
6847 d1
= (struct save_window_data
*) XVECTOR (c1
);
6848 d2
= (struct save_window_data
*) XVECTOR (c2
);
6849 sw1
= XVECTOR (d1
->saved_windows
);
6850 sw2
= XVECTOR (d2
->saved_windows
);
6852 if (d1
->frame_cols
!= d2
->frame_cols
)
6854 if (d1
->frame_lines
!= d2
->frame_lines
)
6856 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
6858 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6860 /* Don't compare the current_window field directly.
6861 Instead see w1_is_current and w2_is_current, below. */
6862 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6864 if (! ignore_positions
)
6866 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6868 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6871 /* Don't compare the root_window field.
6872 We don't require the two configurations
6873 to use the same window object,
6874 and the two root windows must be equivalent
6875 if everything else compares equal. */
6876 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6879 /* Verify that the two confis have the same number of windows. */
6880 if (sw1
->size
!= sw2
->size
)
6883 for (i
= 0; i
< sw1
->size
; i
++)
6885 struct saved_window
*p1
, *p2
;
6886 int w1_is_current
, w2_is_current
;
6888 p1
= SAVED_WINDOW_N (sw1
, i
);
6889 p2
= SAVED_WINDOW_N (sw2
, i
);
6891 /* Verify that the current windows in the two
6892 configurations correspond to each other. */
6893 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6894 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6896 if (w1_is_current
!= w2_is_current
)
6899 /* Verify that the corresponding windows do match. */
6900 if (! EQ (p1
->buffer
, p2
->buffer
))
6902 if (! EQ (p1
->left_col
, p2
->left_col
))
6904 if (! EQ (p1
->top_line
, p2
->top_line
))
6906 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6908 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6910 if (! EQ (p1
->display_table
, p2
->display_table
))
6912 if (! EQ (p1
->parent
, p2
->parent
))
6914 if (! EQ (p1
->prev
, p2
->prev
))
6916 if (! ignore_positions
)
6918 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6920 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6922 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6924 if (NILP (Fequal (p1
->start
, p2
->start
)))
6926 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6928 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6931 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6933 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6935 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6937 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6939 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6941 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6943 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6950 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6951 Scompare_window_configurations
, 2, 2, 0,
6952 doc
: /* Compare two window configurations as regards the structure of windows.
6953 This function ignores details such as the values of point and mark
6954 and scrolling positions. */)
6955 (Lisp_Object x
, Lisp_Object y
)
6957 if (compare_window_configurations (x
, y
, 1))
6963 init_window_once (void)
6965 struct frame
*f
= make_initial_frame ();
6966 XSETFRAME (selected_frame
, f
);
6967 Vterminal_frame
= selected_frame
;
6968 minibuf_window
= f
->minibuffer_window
;
6969 selected_window
= f
->selected_window
;
6970 last_nonminibuf_frame
= f
;
6972 window_initialized
= 1;
6978 Vwindow_list
= Qnil
;
6982 syms_of_window (void)
6984 Qscroll_up
= intern_c_string ("scroll-up");
6985 staticpro (&Qscroll_up
);
6987 Qscroll_down
= intern_c_string ("scroll-down");
6988 staticpro (&Qscroll_down
);
6990 Qscroll_command
= intern_c_string ("scroll-command");
6991 staticpro (&Qscroll_command
);
6993 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6994 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6996 Qwindow_size_fixed
= intern_c_string ("window-size-fixed");
6997 staticpro (&Qwindow_size_fixed
);
6998 Fset (Qwindow_size_fixed
, Qnil
);
7000 staticpro (&Qwindow_configuration_change_hook
);
7001 Qwindow_configuration_change_hook
7002 = intern_c_string ("window-configuration-change-hook");
7004 Qwindowp
= intern_c_string ("windowp");
7005 staticpro (&Qwindowp
);
7007 Qwindow_configuration_p
= intern_c_string ("window-configuration-p");
7008 staticpro (&Qwindow_configuration_p
);
7010 Qwindow_live_p
= intern_c_string ("window-live-p");
7011 staticpro (&Qwindow_live_p
);
7013 Qdisplay_buffer
= intern_c_string ("display-buffer");
7014 staticpro (&Qdisplay_buffer
);
7016 Qtemp_buffer_show_hook
= intern_c_string ("temp-buffer-show-hook");
7017 staticpro (&Qtemp_buffer_show_hook
);
7019 staticpro (&Vwindow_list
);
7021 minibuf_selected_window
= Qnil
;
7022 staticpro (&minibuf_selected_window
);
7024 window_scroll_pixel_based_preserve_x
= -1;
7025 window_scroll_pixel_based_preserve_y
= -1;
7026 window_scroll_preserve_hpos
= -1;
7027 window_scroll_preserve_vpos
= -1;
7029 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
7030 doc
: /* Non-nil means call as function to display a help buffer.
7031 The function is called with one argument, the buffer to be displayed.
7032 Used by `with-output-to-temp-buffer'.
7033 If this function is used, then it must do the entire job of showing
7034 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7035 Vtemp_buffer_show_function
= Qnil
;
7037 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
7038 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7039 Vminibuf_scroll_window
= Qnil
;
7041 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
7042 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7043 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7044 is displayed in the `mode-line' face. */);
7045 mode_line_in_non_selected_windows
= 1;
7047 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
7048 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7049 Vother_window_scroll_buffer
= Qnil
;
7051 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
7052 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7053 auto_window_vscroll_p
= 1;
7055 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
7056 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7057 next_screen_context_lines
= 2;
7059 DEFVAR_INT ("window-min-height", window_min_height
,
7060 doc
: /* Allow deleting windows less than this tall.
7061 The value is measured in line units. If a window wants a modeline it
7062 is counted as one line.
7064 Emacs honors settings of this variable when enlarging or shrinking
7065 windows vertically. A value less than 1 is invalid. */);
7066 window_min_height
= 4;
7068 DEFVAR_INT ("window-min-width", window_min_width
,
7069 doc
: /* Allow deleting windows less than this wide.
7070 The value is measured in characters and includes any fringes or
7073 Emacs honors settings of this variable when enlarging or shrinking
7074 windows horizontally. A value less than 2 is invalid. */);
7075 window_min_width
= 10;
7077 DEFVAR_LISP ("scroll-preserve-screen-position",
7078 Vscroll_preserve_screen_position
,
7079 doc
: /* *Controls if scroll commands move point to keep its screen position unchanged.
7080 A value of nil means point does not keep its screen position except
7081 at the scroll margin or window boundary respectively.
7082 A value of t means point keeps its screen position if the scroll
7083 command moved it vertically out of the window, e.g. when scrolling
7085 Any other value means point always keeps its screen position.
7086 Scroll commands should have the `scroll-command' property
7087 on their symbols to be controlled by this variable. */);
7088 Vscroll_preserve_screen_position
= Qnil
;
7090 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
7091 doc
: /* Type of marker to use for `window-point'. */);
7092 Vwindow_point_insertion_type
= Qnil
;
7094 DEFVAR_LISP ("window-configuration-change-hook",
7095 Vwindow_configuration_change_hook
,
7096 doc
: /* Functions to call when window configuration changes.
7097 The buffer-local part is run once per window, with the relevant window
7098 selected; while the global part is run only once for the modified frame,
7099 with the relevant frame selected. */);
7100 Vwindow_configuration_change_hook
= Qnil
;
7102 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
7103 doc
: /* If non-nil, then the `recenter' command with a nil argument
7104 will redraw the entire frame; the special value `tty' causes the
7105 frame to be redrawn only if it is a tty frame. */);
7106 Vrecenter_redisplay
= Qtty
;
7109 defsubr (&Sselected_window
);
7110 defsubr (&Sminibuffer_window
);
7111 defsubr (&Swindow_minibuffer_p
);
7112 defsubr (&Swindowp
);
7113 defsubr (&Swindow_live_p
);
7114 defsubr (&Spos_visible_in_window_p
);
7115 defsubr (&Swindow_line_height
);
7116 defsubr (&Swindow_buffer
);
7117 defsubr (&Swindow_height
);
7118 defsubr (&Swindow_width
);
7119 defsubr (&Swindow_full_width_p
);
7120 defsubr (&Swindow_hscroll
);
7121 defsubr (&Sset_window_hscroll
);
7122 defsubr (&Swindow_redisplay_end_trigger
);
7123 defsubr (&Sset_window_redisplay_end_trigger
);
7124 defsubr (&Swindow_edges
);
7125 defsubr (&Swindow_pixel_edges
);
7126 defsubr (&Swindow_absolute_pixel_edges
);
7127 defsubr (&Swindow_inside_edges
);
7128 defsubr (&Swindow_inside_pixel_edges
);
7129 defsubr (&Swindow_inside_absolute_pixel_edges
);
7130 defsubr (&Scoordinates_in_window_p
);
7131 defsubr (&Swindow_at
);
7132 defsubr (&Swindow_point
);
7133 defsubr (&Swindow_start
);
7134 defsubr (&Swindow_end
);
7135 defsubr (&Sset_window_point
);
7136 defsubr (&Sset_window_start
);
7137 defsubr (&Swindow_dedicated_p
);
7138 defsubr (&Sset_window_dedicated_p
);
7139 defsubr (&Swindow_display_table
);
7140 defsubr (&Sset_window_display_table
);
7141 defsubr (&Snext_window
);
7142 defsubr (&Sprevious_window
);
7143 defsubr (&Sother_window
);
7144 defsubr (&Sget_lru_window
);
7145 defsubr (&Swindow_use_time
);
7146 defsubr (&Sget_largest_window
);
7147 defsubr (&Sget_buffer_window
);
7148 defsubr (&Sdelete_other_windows
);
7149 defsubr (&Sdelete_windows_on
);
7150 defsubr (&Sreplace_buffer_in_windows
);
7151 defsubr (&Sdelete_window
);
7152 defsubr (&Sset_window_buffer
);
7153 defsubr (&Sselect_window
);
7154 defsubr (&Sforce_window_update
);
7155 defsubr (&Stemp_output_buffer_show
);
7156 defsubr (&Ssplit_window
);
7157 defsubr (&Senlarge_window
);
7158 defsubr (&Sshrink_window
);
7159 defsubr (&Sadjust_window_trailing_edge
);
7160 defsubr (&Sscroll_up
);
7161 defsubr (&Sscroll_down
);
7162 defsubr (&Sscroll_left
);
7163 defsubr (&Sscroll_right
);
7164 defsubr (&Sother_window_for_scrolling
);
7165 defsubr (&Sscroll_other_window
);
7166 defsubr (&Sminibuffer_selected_window
);
7167 defsubr (&Srecenter
);
7168 defsubr (&Swindow_text_height
);
7169 defsubr (&Smove_to_window_line
);
7170 defsubr (&Swindow_configuration_p
);
7171 defsubr (&Swindow_configuration_frame
);
7172 defsubr (&Sset_window_configuration
);
7173 defsubr (&Scurrent_window_configuration
);
7174 defsubr (&Swindow_tree
);
7175 defsubr (&Sset_window_margins
);
7176 defsubr (&Swindow_margins
);
7177 defsubr (&Sset_window_fringes
);
7178 defsubr (&Swindow_fringes
);
7179 defsubr (&Sset_window_scroll_bars
);
7180 defsubr (&Swindow_scroll_bars
);
7181 defsubr (&Swindow_vscroll
);
7182 defsubr (&Sset_window_vscroll
);
7183 defsubr (&Scompare_window_configurations
);
7184 defsubr (&Swindow_list
);
7185 defsubr (&Swindow_parameters
);
7186 defsubr (&Swindow_parameter
);
7187 defsubr (&Sset_window_parameter
);
7192 keys_of_window (void)
7194 initial_define_key (control_x_map
, '1', "delete-other-windows");
7195 initial_define_key (control_x_map
, '2', "split-window");
7196 initial_define_key (control_x_map
, '0', "delete-window");
7197 initial_define_key (control_x_map
, 'o', "other-window");
7198 initial_define_key (control_x_map
, '^', "enlarge-window");
7199 initial_define_key (control_x_map
, '<', "scroll-left");
7200 initial_define_key (control_x_map
, '>', "scroll-right");
7202 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
7203 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7204 initial_define_key (meta_map
, 'v', "scroll-down-command");