1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
36 #include "dispextern.h"
37 #include "blockinput.h"
38 #include "intervals.h"
39 #include "termhooks.h" /* For FRAME_TERMINAL. */
43 #endif /* HAVE_X_WINDOWS */
55 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
56 Lisp_Object Qdisplay_buffer
;
57 Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
58 Lisp_Object Qwindow_size_fixed
;
60 extern Lisp_Object Qleft_margin
, Qright_margin
;
62 static int displayed_window_lines (struct window
*);
63 static struct window
*decode_window (Lisp_Object
);
64 static int count_windows (struct window
*);
65 static int get_leaf_windows (struct window
*, struct window
**, int);
66 static void window_scroll (Lisp_Object
, int, int, int);
67 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
68 static void window_scroll_line_based (Lisp_Object
, int, int, int);
69 static int window_min_size_1 (struct window
*, int, int);
70 static int window_min_size_2 (struct window
*, int, int);
71 static int window_min_size (struct window
*, int, int, int, int *);
72 static void size_window (Lisp_Object
, int, int, int, int, int);
73 static int freeze_window_start (struct window
*, void *);
74 static int window_fixed_size_p (struct window
*, int, int);
75 static void enlarge_window (Lisp_Object
, int, int);
76 static Lisp_Object
window_list (void);
77 static int add_window_to_list (struct window
*, void *);
78 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
80 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
82 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
84 static int foreach_window_1 (struct window
*,
85 int (* fn
) (struct window
*, void *),
87 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
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 /* Non-nil means it is the window for C-M-v to scroll
118 when the mini-buffer is selected. */
120 Lisp_Object Vminibuf_scroll_window
;
122 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
124 Lisp_Object Vother_window_scroll_buffer
;
126 /* Non-nil means it's function to call to display temp buffers. */
128 Lisp_Object Vtemp_buffer_show_function
;
130 /* Non-zero means line and page scrolling on tall lines (with images)
131 does partial scrolling by modifying window-vscroll. */
133 int auto_window_vscroll_p
;
135 /* Non-zero means to use mode-line-inactive face in all windows but the
136 selected-window and the minibuffer-scroll-window when the
137 minibuffer is active. */
138 int mode_line_in_non_selected_windows
;
140 /* If a window gets smaller than either of these, it is removed. */
142 EMACS_INT window_min_height
;
143 EMACS_INT window_min_width
;
145 /* Hook run at end of temp_output_buffer_show. */
147 Lisp_Object Qtemp_buffer_show_hook
;
149 /* Number of lines of continuity in scrolling by screenfuls. */
151 EMACS_INT next_screen_context_lines
;
153 /* Incremented for each window created. */
155 static int sequence_number
;
157 /* Nonzero after init_window_once has finished. */
159 static int window_initialized
;
161 /* Hook to run when window config changes. */
163 static Lisp_Object Qwindow_configuration_change_hook
;
164 static Lisp_Object Vwindow_configuration_change_hook
;
166 /* Non-nil means scroll commands try to put point
167 at the same screen height as previously. */
169 Lisp_Object Vscroll_preserve_screen_position
;
171 /* Non-nil means that text is inserted before window's markers. */
173 Lisp_Object Vwindow_point_insertion_type
;
175 /* Incremented by 1 whenever a window is deleted. */
177 int window_deletion_count
;
179 /* Used by the function window_scroll_pixel_based */
181 static int window_scroll_pixel_based_preserve_x
;
182 static int window_scroll_pixel_based_preserve_y
;
184 /* Same for window_scroll_line_based. */
186 static int window_scroll_preserve_hpos
;
187 static int window_scroll_preserve_vpos
;
189 #if 0 /* This isn't used anywhere. */
190 /* Nonzero means we can split a frame even if it is "unsplittable". */
191 static int inhibit_frame_unsplittable
;
194 extern EMACS_INT scroll_margin
;
196 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
198 /* If non-nil, then the `recenter' command with a nil argument
199 the entire frame to be redrawn; the special value `tty' causes the
200 frame to be redrawn only if it is a tty frame. */
202 static Lisp_Object Vrecenter_redisplay
;
203 extern Lisp_Object Qtty
;
206 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
207 doc
: /* Return t if OBJECT is a window. */)
211 return WINDOWP (object
) ? Qt
: Qnil
;
214 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
215 doc
: /* Return t if OBJECT is a window which is currently visible. */)
219 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
226 register struct window
*p
;
228 p
= allocate_window ();
230 XSETFASTINT (p
->sequence_number
, sequence_number
);
231 XSETFASTINT (p
->left_col
, 0);
232 XSETFASTINT (p
->top_line
, 0);
233 XSETFASTINT (p
->total_lines
, 0);
234 XSETFASTINT (p
->total_cols
, 0);
235 XSETFASTINT (p
->hscroll
, 0);
236 XSETFASTINT (p
->min_hscroll
, 0);
237 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
238 p
->start
= Fmake_marker ();
239 p
->pointm
= Fmake_marker ();
240 XSETFASTINT (p
->use_time
, 0);
242 p
->display_table
= Qnil
;
244 p
->window_parameters
= Qnil
;
245 p
->pseudo_window_p
= 0;
246 bzero (&p
->cursor
, sizeof (p
->cursor
));
247 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
248 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
249 p
->desired_matrix
= p
->current_matrix
= 0;
250 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
251 p
->phys_cursor_type
= -1;
252 p
->phys_cursor_width
= -1;
253 p
->must_be_updated_p
= 0;
254 XSETFASTINT (p
->window_end_vpos
, 0);
255 XSETFASTINT (p
->window_end_pos
, 0);
256 p
->window_end_valid
= Qnil
;
259 XSETFASTINT (p
->last_point
, 0);
260 p
->frozen_window_start_p
= 0;
261 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
262 p
->left_margin_cols
= Qnil
;
263 p
->right_margin_cols
= Qnil
;
264 p
->left_fringe_width
= Qnil
;
265 p
->right_fringe_width
= Qnil
;
266 p
->fringes_outside_margins
= Qnil
;
267 p
->scroll_bar_width
= Qnil
;
268 p
->vertical_scroll_bar_type
= Qt
;
269 p
->resize_proportionally
= Qnil
;
275 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
276 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
279 return selected_window
;
282 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
283 doc
: /* Return the window used now for minibuffers.
284 If the optional argument FRAME is specified, return the minibuffer window
285 used by that frame. */)
290 frame
= selected_frame
;
291 CHECK_LIVE_FRAME (frame
);
292 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
295 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
296 doc
: /* Return non-nil if WINDOW is a minibuffer window.
297 WINDOW defaults to the selected window. */)
301 struct window
*w
= decode_window (window
);
302 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
306 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
307 Spos_visible_in_window_p
, 0, 3, 0,
308 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
309 Return nil if that position is scrolled vertically out of view.
310 If a character is only partially visible, nil is returned, unless the
311 optional argument PARTIALLY is non-nil.
312 If POS is only out of view because of horizontal scrolling, return non-nil.
313 If POS is t, it specifies the position of the last visible glyph in WINDOW.
314 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
316 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
317 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
318 where X and Y are the pixel coordinates relative to the top left corner
319 of the window. The remaining elements are omitted if the character after
320 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
321 off-window at the top and bottom of the row, ROWH is the height of the
322 display row, and VPOS is the row number (0-based) containing POS. */)
323 (pos
, window
, partially
)
324 Lisp_Object pos
, window
, partially
;
326 register struct window
*w
;
328 register struct buffer
*buf
;
330 Lisp_Object in_window
= Qnil
;
331 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
334 w
= decode_window (window
);
335 buf
= XBUFFER (w
->buffer
);
336 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
340 else if (!NILP (pos
))
342 CHECK_NUMBER_COERCE_MARKER (pos
);
345 else if (w
== XWINDOW (selected_window
))
348 posint
= XMARKER (w
->pointm
)->charpos
;
350 /* If position is above window start or outside buffer boundaries,
351 or if window start is out of range, position is not visible. */
353 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
354 && CHARPOS (top
) >= BUF_BEGV (buf
)
355 && CHARPOS (top
) <= BUF_ZV (buf
)
356 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
357 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
360 if (!NILP (in_window
) && !NILP (partially
))
362 Lisp_Object part
= Qnil
;
364 part
= list4 (make_number (rtop
), make_number (rbot
),
365 make_number (rowh
), make_number (vpos
));
366 in_window
= Fcons (make_number (x
),
367 Fcons (make_number (y
), part
));
373 DEFUN ("window-line-height", Fwindow_line_height
,
374 Swindow_line_height
, 0, 2, 0,
375 doc
: /* Return height in pixels of text line LINE in window WINDOW.
376 If WINDOW is nil or omitted, use selected window.
378 Return height of current line if LINE is omitted or nil. Return height of
379 header or mode line if LINE is `header-line' and `mode-line'.
380 Otherwise, LINE is a text line number starting from 0. A negative number
381 counts from the end of the window.
383 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
384 in pixels of the visible part of the line, VPOS and YPOS are the
385 vertical position in lines and pixels of the line, relative to the top
386 of the first text line, and OFFBOT is the number of off-window pixels at
387 the bottom of the text line. If there are off-window pixels at the top
388 of the (first) text line, YPOS is negative.
390 Return nil if window display is not up-to-date. In that case, use
391 `pos-visible-in-window-p' to obtain the information. */)
393 Lisp_Object line
, window
;
395 register struct window
*w
;
396 register struct buffer
*b
;
397 struct glyph_row
*row
, *end_row
;
398 int max_y
, crop
, i
, n
;
400 w
= decode_window (window
);
403 || w
->pseudo_window_p
)
406 CHECK_BUFFER (w
->buffer
);
407 b
= XBUFFER (w
->buffer
);
409 /* Fail if current matrix is not up-to-date. */
410 if (NILP (w
->window_end_valid
)
411 || current_buffer
->clip_changed
412 || current_buffer
->prevent_redisplay_optimizations_p
413 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
414 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
420 if (i
< 0 || i
>= w
->current_matrix
->nrows
421 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
423 max_y
= window_text_bottom_y (w
);
427 if (EQ (line
, Qheader_line
))
429 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
431 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
434 return list4 (make_number (row
->height
),
435 make_number (0), make_number (0),
439 if (EQ (line
, Qmode_line
))
441 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
444 return list4 (make_number (row
->height
),
445 make_number (0), /* not accurate */
446 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
447 + window_text_bottom_y (w
)),
454 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
455 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
456 max_y
= window_text_bottom_y (w
);
459 while ((n
< 0 || i
< n
)
460 && row
<= end_row
&& row
->enabled_p
461 && row
->y
+ row
->height
< max_y
)
464 if (row
> end_row
|| !row
->enabled_p
)
476 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
477 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
479 make_number (row
->y
),
485 static struct window
*
486 decode_window (register Lisp_Object window
)
489 return XWINDOW (selected_window
);
491 CHECK_LIVE_WINDOW (window
);
492 return XWINDOW (window
);
495 static struct window
*
496 decode_any_window (register Lisp_Object window
)
499 return XWINDOW (selected_window
);
501 CHECK_WINDOW (window
);
502 return XWINDOW (window
);
505 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
506 doc
: /* Return the buffer that WINDOW is displaying.
507 WINDOW defaults to the selected window. */)
511 return decode_window (window
)->buffer
;
514 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
515 doc
: /* Return the number of lines in WINDOW.
516 WINDOW defaults to the selected window.
518 The return value includes WINDOW's mode line and header line, if any. */)
522 return decode_any_window (window
)->total_lines
;
525 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
526 doc
: /* Return the number of display columns in WINDOW.
527 WINDOW defaults to the selected window.
529 Note: The return value is the number of columns available for text in
530 WINDOW. If you want to find out how many columns WINDOW takes up, use
531 (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
535 return make_number (window_box_text_cols (decode_any_window (window
)));
538 DEFUN ("window-full-width-p", Fwindow_full_width_p
, Swindow_full_width_p
, 0, 1, 0,
539 doc
: /* Return t if WINDOW is as wide as its frame.
540 WINDOW defaults to the selected window. */)
544 return WINDOW_FULL_WIDTH_P (decode_any_window (window
)) ? Qt
: Qnil
;
547 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
548 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
549 WINDOW defaults to the selected window. */)
553 return decode_window (window
)->hscroll
;
556 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
557 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
558 Return NCOL. NCOL should be zero or positive.
560 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
561 window so that the location of point moves off-window. */)
563 Lisp_Object window
, ncol
;
565 struct window
*w
= decode_window (window
);
569 hscroll
= max (0, XINT (ncol
));
571 /* Prevent redisplay shortcuts when changing the hscroll. */
572 if (XINT (w
->hscroll
) != hscroll
)
573 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
575 w
->hscroll
= make_number (hscroll
);
579 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
580 Swindow_redisplay_end_trigger
, 0, 1, 0,
581 doc
: /* Return WINDOW's redisplay end trigger value.
582 WINDOW defaults to the selected window.
583 See `set-window-redisplay-end-trigger' for more information. */)
587 return decode_window (window
)->redisplay_end_trigger
;
590 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
591 Sset_window_redisplay_end_trigger
, 2, 2, 0,
592 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
593 VALUE should be a buffer position (typically a marker) or nil.
594 If it is a buffer position, then if redisplay in WINDOW reaches a position
595 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
596 with two arguments: WINDOW, and the end trigger value.
597 Afterwards the end-trigger value is reset to nil. */)
599 register Lisp_Object window
, value
;
601 register struct window
*w
;
603 w
= decode_window (window
);
604 w
->redisplay_end_trigger
= value
;
608 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
609 doc
: /* Return a list of the edge coordinates of WINDOW.
610 The list has the form (LEFT TOP RIGHT BOTTOM).
611 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
612 all relative to 0, 0 at top left corner of frame.
614 RIGHT is one more than the rightmost column occupied by WINDOW.
615 BOTTOM is one more than the bottommost row occupied by WINDOW.
616 The edges include the space used by WINDOW's scroll bar, display
617 margins, fringes, header line, and/or mode line. For the edges of
618 just the text area, use `window-inside-edges'. */)
622 register struct window
*w
= decode_any_window (window
);
624 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
625 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
626 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
627 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
631 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
632 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
633 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
634 the top left corner of the frame.
636 RIGHT is one more than the rightmost x position occupied by WINDOW.
637 BOTTOM is one more than the bottommost y position occupied by WINDOW.
638 The pixel edges include the space used by WINDOW's scroll bar, display
639 margins, fringes, header line, and/or mode line. For the pixel edges
640 of just the text area, use `window-inside-pixel-edges'. */)
644 register struct window
*w
= decode_any_window (window
);
646 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
647 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
648 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
649 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
654 calc_absolute_offset(struct window
*w
, int *add_x
, int *add_y
)
656 struct frame
*f
= XFRAME (w
->frame
);
658 #ifdef FRAME_MENUBAR_HEIGHT
659 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
661 #ifdef FRAME_TOOLBAR_HEIGHT
662 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
664 #ifdef FRAME_NS_TITLEBAR_HEIGHT
665 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
667 *add_x
= f
->left_pos
;
670 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
671 Swindow_absolute_pixel_edges
, 0, 1, 0,
672 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
673 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
674 the top left corner of the display.
676 RIGHT is one more than the rightmost x position occupied by WINDOW.
677 BOTTOM is one more than the bottommost y position occupied by WINDOW.
678 The pixel edges include the space used by WINDOW's scroll bar, display
679 margins, fringes, header line, and/or mode line. For the pixel edges
680 of just the text area, use `window-inside-absolute-pixel-edges'. */)
684 register struct window
*w
= decode_any_window (window
);
686 calc_absolute_offset(w
, &add_x
, &add_y
);
688 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
689 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
690 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
691 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
695 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
696 doc
: /* Return a list of the edge coordinates of WINDOW.
697 The list has the form (LEFT TOP RIGHT BOTTOM).
698 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
699 all relative to 0, 0 at top left corner of frame.
701 RIGHT is one more than the rightmost column of WINDOW's text area.
702 BOTTOM is one more than the bottommost row of WINDOW's text area.
703 The inside edges do not include the space used by the WINDOW's scroll
704 bar, display margins, fringes, header line, and/or mode line. */)
708 register struct window
*w
= decode_any_window (window
);
710 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
711 + WINDOW_LEFT_MARGIN_COLS (w
)
712 + WINDOW_LEFT_FRINGE_COLS (w
)),
713 make_number (WINDOW_TOP_EDGE_LINE (w
)
714 + WINDOW_HEADER_LINE_LINES (w
)),
715 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
716 - WINDOW_RIGHT_MARGIN_COLS (w
)
717 - WINDOW_RIGHT_FRINGE_COLS (w
)),
718 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
719 - WINDOW_MODE_LINE_LINES (w
)));
722 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
723 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
724 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
725 the top left corner of the frame.
727 RIGHT is one more than the rightmost x position of WINDOW's text area.
728 BOTTOM is one more than the bottommost y position of WINDOW's text area.
729 The inside edges do not include the space used by WINDOW's scroll bar,
730 display margins, fringes, header line, and/or mode line. */)
734 register struct window
*w
= decode_any_window (window
);
736 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
737 + WINDOW_LEFT_MARGIN_WIDTH (w
)
738 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
739 make_number (WINDOW_TOP_EDGE_Y (w
)
740 + WINDOW_HEADER_LINE_HEIGHT (w
)),
741 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
742 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
743 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
744 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
745 - WINDOW_MODE_LINE_HEIGHT (w
)));
748 DEFUN ("window-inside-absolute-pixel-edges",
749 Fwindow_inside_absolute_pixel_edges
,
750 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
751 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
752 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
753 the top left corner of the display.
755 RIGHT is one more than the rightmost x position of WINDOW's text area.
756 BOTTOM is one more than the bottommost y position of WINDOW's text area.
757 The inside edges do not include the space used by WINDOW's scroll bar,
758 display margins, fringes, header line, and/or mode line. */)
762 register struct window
*w
= decode_any_window (window
);
764 calc_absolute_offset(w
, &add_x
, &add_y
);
766 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
767 + WINDOW_LEFT_MARGIN_WIDTH (w
)
768 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
769 make_number (WINDOW_TOP_EDGE_Y (w
)
770 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
771 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
772 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
773 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
774 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
775 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
778 /* Test if the character at column *X, row *Y is within window W.
779 If it is not, return ON_NOTHING;
780 if it is in the window's text area,
781 set *x and *y to its location relative to the upper left corner
784 if it is on the window's modeline, return ON_MODE_LINE;
785 if it is on the border between the window and its right sibling,
786 return ON_VERTICAL_BORDER.
787 if it is on a scroll bar,
788 return ON_SCROLL_BAR.
789 if it is on the window's top line, return ON_HEADER_LINE;
790 if it is in left or right fringe of the window,
791 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
792 to window-relative coordinates;
793 if it is in the marginal area to the left/right of the window,
794 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
795 to window-relative coordinates.
797 X and Y are frame relative pixel coordinates. */
799 static enum window_part
800 coordinates_in_window (register struct window
*w
, register int *x
, register int *y
)
802 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
803 int left_x
, right_x
, top_y
, bottom_y
;
804 enum window_part part
;
805 int ux
= FRAME_COLUMN_WIDTH (f
);
806 int x0
= WINDOW_LEFT_EDGE_X (w
);
807 int x1
= WINDOW_RIGHT_EDGE_X (w
);
808 /* The width of the area where the vertical line can be dragged.
809 (Between mode lines for instance. */
810 int grabbable_width
= ux
;
811 int lmargin_width
, rmargin_width
, text_left
, text_right
;
813 /* In what's below, we subtract 1 when computing right_x because we
814 want the rightmost pixel, which is given by left_pixel+width-1. */
815 if (w
->pseudo_window_p
)
818 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
819 top_y
= WINDOW_TOP_EDGE_Y (w
);
820 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
824 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
825 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
826 top_y
= WINDOW_TOP_EDGE_Y (w
);
827 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
830 /* Outside any interesting row? */
831 if (*y
< top_y
|| *y
>= bottom_y
)
834 /* On the mode line or header line? If it's near the start of
835 the mode or header line of window that's has a horizontal
836 sibling, say it's on the vertical line. That's to be able
837 to resize windows horizontally in case we're using toolkit
840 if (WINDOW_WANTS_MODELINE_P (w
)
841 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
845 header_vertical_border_check
:
846 /* We're somewhere on the mode line. We consider the place
847 between mode lines of horizontally adjacent mode lines
848 as the vertical border. If scroll bars on the left,
849 return the right window. */
850 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
851 || WINDOW_RIGHTMOST_P (w
))
853 if (!WINDOW_LEFTMOST_P (w
) && eabs (*x
- x0
) < grabbable_width
)
855 /* Convert X and Y to window relative coordinates.
856 Vertical border is at the left edge of window. */
857 *x
= max (0, *x
- x0
);
859 return ON_VERTICAL_BORDER
;
864 /* Make sure we're not at the rightmost position of a
865 mode-/header-line and there's yet another window on
866 the right. (Bug#1372) */
867 if ((WINDOW_RIGHTMOST_P (w
) || *x
< x1
)
868 && eabs (*x
- x1
) < grabbable_width
)
870 /* Convert X and Y to window relative coordinates.
871 Vertical border is at the right edge of window. */
872 *x
= min (x1
, *x
) - x0
;
874 return ON_VERTICAL_BORDER
;
878 if (*x
< x0
|| *x
>= x1
)
881 /* Convert X and Y to window relative coordinates.
882 Mode line starts at left edge of window. */
888 if (WINDOW_WANTS_HEADER_LINE_P (w
)
889 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
891 part
= ON_HEADER_LINE
;
892 goto header_vertical_border_check
;
895 if (*x
< x0
|| *x
>= x1
)
898 /* Outside any interesting column? */
899 if (*x
< left_x
|| *x
> right_x
)
902 return ON_SCROLL_BAR
;
905 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
906 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
908 text_left
= window_box_left (w
, TEXT_AREA
);
909 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
911 if (FRAME_WINDOW_P (f
))
913 if (!w
->pseudo_window_p
914 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
915 && !WINDOW_RIGHTMOST_P (w
)
916 && (eabs (*x
- right_x
) < grabbable_width
))
918 /* Convert X and Y to window relative coordinates.
919 Vertical border is at the right edge of window. */
920 *x
= min (right_x
, *x
) - left_x
;
922 return ON_VERTICAL_BORDER
;
927 /* Need to say "*x > right_x" rather than >=, since on character
928 terminals, the vertical line's x coordinate is right_x. */
929 if (!w
->pseudo_window_p
930 && !WINDOW_RIGHTMOST_P (w
)
931 && *x
> right_x
- ux
)
933 /* On the border on the right side of the window? Assume that
934 this area begins at RIGHT_X minus a canonical char width. */
935 *x
= min (right_x
, *x
) - left_x
;
937 return ON_VERTICAL_BORDER
;
943 if (lmargin_width
> 0
944 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
945 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
946 : (*x
< left_x
+ lmargin_width
)))
949 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
950 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
952 return ON_LEFT_MARGIN
;
955 /* Convert X and Y to window-relative pixel coordinates. */
958 return ON_LEFT_FRINGE
;
961 if (*x
>= text_right
)
963 if (rmargin_width
> 0
964 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
965 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
966 : (*x
>= right_x
- rmargin_width
)))
968 *x
-= right_x
- rmargin_width
;
969 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
970 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
972 return ON_RIGHT_MARGIN
;
975 /* Convert X and Y to window-relative pixel coordinates. */
976 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
978 return ON_RIGHT_FRINGE
;
981 /* Everything special ruled out - must be on text area */
988 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
989 Scoordinates_in_window_p
, 2, 2, 0,
990 doc
: /* Return non-nil if COORDINATES are in WINDOW.
991 COORDINATES is a cons of the form (X . Y), X and Y being distances
992 measured in characters from the upper-left corner of the frame.
993 \(0 . 0) denotes the character in the upper left corner of the
995 If COORDINATES are in the text portion of WINDOW,
996 the coordinates relative to the window are returned.
997 If they are in the mode line of WINDOW, `mode-line' is returned.
998 If they are in the top mode line of WINDOW, `header-line' is returned.
999 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1000 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1001 If they are on the border between WINDOW and its right sibling,
1002 `vertical-line' is returned.
1003 If they are in the windows's left or right marginal areas, `left-margin'\n\
1004 or `right-margin' is returned. */)
1005 (coordinates
, window
)
1006 register Lisp_Object coordinates
, window
;
1013 CHECK_WINDOW (window
);
1014 w
= XWINDOW (window
);
1015 f
= XFRAME (w
->frame
);
1016 CHECK_CONS (coordinates
);
1017 lx
= Fcar (coordinates
);
1018 ly
= Fcdr (coordinates
);
1019 CHECK_NUMBER_OR_FLOAT (lx
);
1020 CHECK_NUMBER_OR_FLOAT (ly
);
1021 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1022 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1024 switch (coordinates_in_window (w
, &x
, &y
))
1030 /* X and Y are now window relative pixel coordinates. Convert
1031 them to canonical char units before returning them. */
1032 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1033 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1038 case ON_VERTICAL_BORDER
:
1039 return Qvertical_line
;
1041 case ON_HEADER_LINE
:
1042 return Qheader_line
;
1044 case ON_LEFT_FRINGE
:
1045 return Qleft_fringe
;
1047 case ON_RIGHT_FRINGE
:
1048 return Qright_fringe
;
1050 case ON_LEFT_MARGIN
:
1051 return Qleft_margin
;
1053 case ON_RIGHT_MARGIN
:
1054 return Qright_margin
;
1057 /* Historically we are supposed to return nil in this case. */
1066 /* Callback for foreach_window, used in window_from_coordinates.
1067 Check if window W contains coordinates specified by USER_DATA which
1068 is actually a pointer to a struct check_window_data CW.
1070 Check if window W contains coordinates *CW->x and *CW->y. If it
1071 does, return W in *CW->window, as Lisp_Object, and return in
1072 *CW->part the part of the window under coordinates *X,*Y. Return
1073 zero from this function to stop iterating over windows. */
1075 struct check_window_data
1077 Lisp_Object
*window
;
1079 enum window_part
*part
;
1083 check_window_containing (struct window
*w
, void *user_data
)
1085 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1086 enum window_part found
;
1089 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1090 if (found
!= ON_NOTHING
)
1093 XSETWINDOW (*cw
->window
, w
);
1101 /* Find the window containing frame-relative pixel position X/Y and
1102 return it as a Lisp_Object.
1104 If X, Y is on one of the window's special `window_part' elements,
1105 set *PART to the id of that element, and return X and Y converted
1106 to window relative coordinates in WX and WY.
1108 If there is no window under X, Y return nil and leave *PART
1109 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1111 This function was previously implemented with a loop cycling over
1112 windows with Fnext_window, and starting with the frame's selected
1113 window. It turned out that this doesn't work with an
1114 implementation of next_window using Vwindow_list, because
1115 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1116 tree of F when this function is called asynchronously from
1117 note_mouse_highlight. The original loop didn't terminate in this
1121 window_from_coordinates (struct frame
*f
, int x
, int y
, enum window_part
*part
, int *wx
, int *wy
, int tool_bar_p
)
1124 struct check_window_data cw
;
1125 enum window_part dummy
;
1131 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1132 foreach_window (f
, check_window_containing
, &cw
);
1134 /* If not found above, see if it's in the tool bar window, if a tool
1138 && WINDOWP (f
->tool_bar_window
)
1139 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1140 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1144 window
= f
->tool_bar_window
;
1153 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1154 doc
: /* Return window containing coordinates X and Y on FRAME.
1155 If omitted, FRAME defaults to the currently selected frame.
1156 The top left corner of the frame is considered to be row 0,
1159 Lisp_Object x
, y
, frame
;
1164 frame
= selected_frame
;
1165 CHECK_LIVE_FRAME (frame
);
1168 /* Check that arguments are integers or floats. */
1169 CHECK_NUMBER_OR_FLOAT (x
);
1170 CHECK_NUMBER_OR_FLOAT (y
);
1172 return window_from_coordinates (f
,
1173 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1174 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1175 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1176 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1180 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1181 doc
: /* Return current value of point in WINDOW.
1182 WINDOW defaults to the selected window.
1184 For a nonselected window, this is the value point would have
1185 if that window were selected.
1187 Note that, when WINDOW is the selected window and its buffer
1188 is also currently selected, the value returned is the same as (point).
1189 It would be more strictly correct to return the `top-level' value
1190 of point, outside of any save-excursion forms.
1191 But that is hard to define. */)
1195 register struct window
*w
= decode_window (window
);
1197 if (w
== XWINDOW (selected_window
)
1198 && current_buffer
== XBUFFER (w
->buffer
))
1200 return Fmarker_position (w
->pointm
);
1203 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1204 doc
: /* Return position at which display currently starts in WINDOW.
1205 WINDOW defaults to the selected window.
1206 This is updated by redisplay or by calling `set-window-start'. */)
1210 return Fmarker_position (decode_window (window
)->start
);
1213 /* This is text temporarily removed from the doc string below.
1215 This function returns nil if the position is not currently known.
1216 That happens when redisplay is preempted and doesn't finish.
1217 If in that case you want to compute where the end of the window would
1218 have been if redisplay had finished, do this:
1220 (goto-char (window-start window))
1221 (vertical-motion (1- (window-height window)) window)
1224 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1225 doc
: /* Return position at which display currently ends in WINDOW.
1226 WINDOW defaults to the selected window.
1227 This is updated by redisplay, when it runs to completion.
1228 Simply changing the buffer text or setting `window-start'
1229 does not update this value.
1230 Return nil if there is no recorded value. \(This can happen if the
1231 last redisplay of WINDOW was preempted, and did not finish.)
1232 If UPDATE is non-nil, compute the up-to-date position
1233 if it isn't already recorded. */)
1235 Lisp_Object window
, update
;
1238 struct window
*w
= decode_window (window
);
1246 #if 0 /* This change broke some things. We should make it later. */
1247 /* If we don't know the end position, return nil.
1248 The user can compute it with vertical-motion if he wants to.
1249 It would be nicer to do it automatically,
1250 but that's so slow that it would probably bother people. */
1251 if (NILP (w
->window_end_valid
))
1256 && ! (! NILP (w
->window_end_valid
)
1257 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1258 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1261 struct text_pos startp
;
1263 struct buffer
*old_buffer
= NULL
;
1265 /* Cannot use Fvertical_motion because that function doesn't
1266 cope with variable-height lines. */
1267 if (b
!= current_buffer
)
1269 old_buffer
= current_buffer
;
1270 set_buffer_internal (b
);
1273 /* In case W->start is out of the range, use something
1274 reasonable. This situation occurred when loading a file with
1275 `-l' containing a call to `rmail' with subsequent other
1276 commands. At the end, W->start happened to be BEG, while
1277 rmail had already narrowed the buffer. */
1278 if (XMARKER (w
->start
)->charpos
< BEGV
)
1279 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1280 else if (XMARKER (w
->start
)->charpos
> ZV
)
1281 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1283 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1285 start_display (&it
, w
, startp
);
1286 move_it_vertically (&it
, window_box_height (w
));
1287 if (it
.current_y
< it
.last_visible_y
)
1288 move_it_past_eol (&it
);
1289 value
= make_number (IT_CHARPOS (it
));
1292 set_buffer_internal (old_buffer
);
1295 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1300 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1301 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1304 Lisp_Object window
, pos
;
1306 register struct window
*w
= decode_window (window
);
1308 CHECK_NUMBER_COERCE_MARKER (pos
);
1309 if (w
== XWINDOW (selected_window
)
1310 && XBUFFER (w
->buffer
) == current_buffer
)
1313 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1315 /* We have to make sure that redisplay updates the window to show
1316 the new value of point. */
1317 if (!EQ (window
, selected_window
))
1318 ++windows_or_buffers_changed
;
1323 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1324 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1325 WINDOW defaults to the selected window. Return POS.
1326 Optional third arg NOFORCE non-nil inhibits next redisplay from
1327 overriding motion of point in order to display at this exact start. */)
1328 (window
, pos
, noforce
)
1329 Lisp_Object window
, pos
, noforce
;
1331 register struct window
*w
= decode_window (window
);
1333 CHECK_NUMBER_COERCE_MARKER (pos
);
1334 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1335 /* this is not right, but much easier than doing what is right. */
1336 w
->start_at_line_beg
= Qnil
;
1338 w
->force_start
= Qt
;
1339 w
->update_mode_line
= Qt
;
1340 XSETFASTINT (w
->last_modified
, 0);
1341 XSETFASTINT (w
->last_overlay_modified
, 0);
1342 if (!EQ (window
, selected_window
))
1343 windows_or_buffers_changed
++;
1349 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1351 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1352 More precisely, return the value assigned by the last call of
1353 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1354 never called with WINDOW as its argument, or the value set by that
1355 function was internally reset since its last call. WINDOW defaults to
1356 the selected window.
1358 When a window is dedicated to its buffer, `display-buffer' will refrain
1359 from displaying another buffer in it. `get-lru-window' and
1360 `get-largest-window' treat dedicated windows specially.
1361 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1362 `kill-buffer' can delete a dedicated window and the containing frame.
1364 Functions like `set-window-buffer' may change the buffer displayed by a
1365 window, unless that window is "strongly" dedicated to its buffer, that
1366 is the value returned by `window-dedicated-p' is t. */)
1370 return decode_window (window
)->dedicated
;
1373 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1374 Sset_window_dedicated_p
, 2, 2, 0,
1375 doc
: /* Mark WINDOW as dedicated according to FLAG.
1376 WINDOW defaults to the selected window. FLAG non-nil means mark WINDOW
1377 as dedicated to its buffer. FLAG nil means mark WINDOW as non-dedicated.
1380 When a window is dedicated to its buffer, `display-buffer' will refrain
1381 from displaying another buffer in it. `get-lru-window' and
1382 `get-largest-window' treat dedicated windows specially.
1383 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1384 `kill-buffer' can delete a dedicated window and the containing
1387 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1388 its buffer. Functions like `set-window-buffer' may change the buffer
1389 displayed by a window, unless that window is strongly dedicated to its
1390 buffer. If and when `set-window-buffer' displays another buffer in a
1391 window, it also makes sure that the window is not marked as dedicated. */)
1393 Lisp_Object window
, flag
;
1395 register struct window
*w
= decode_window (window
);
1397 w
->dedicated
= flag
;
1398 return w
->dedicated
;
1402 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1404 doc
: /* Return the parameters of WINDOW and their values.
1405 WINDOW defaults to the selected window. The return value is a list of
1406 elements of the form (PARAMETER . VALUE). */)
1410 return Fcopy_alist (decode_window (window
)->window_parameters
);
1413 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1415 doc
: /* Return WINDOW's value for PARAMETER.
1416 WINDOW defaults to the selected window. */)
1418 Lisp_Object window
, parameter
;
1422 result
= Fassq (parameter
, decode_window (window
)->window_parameters
);
1423 return CDR_SAFE (result
);
1426 DEFUN ("set-window-parameter", Fset_window_parameter
,
1427 Sset_window_parameter
, 3, 3, 0,
1428 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1429 WINDOW defaults to the selected window. Return VALUE. */)
1430 (window
, parameter
, value
)
1431 Lisp_Object window
, parameter
, value
;
1433 register struct window
*w
= decode_window (window
);
1434 Lisp_Object old_alist_elt
;
1436 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1437 if (NILP (old_alist_elt
))
1438 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1440 Fsetcdr (old_alist_elt
, value
);
1445 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1447 doc
: /* Return the display-table that WINDOW is using.
1448 WINDOW defaults to the selected window. */)
1452 return decode_window (window
)->display_table
;
1455 /* Get the display table for use on window W. This is either W's
1456 display table or W's buffer's display table. Ignore the specified
1457 tables if they are not valid; if no valid table is specified,
1460 struct Lisp_Char_Table
*
1461 window_display_table (struct window
*w
)
1463 struct Lisp_Char_Table
*dp
= NULL
;
1465 if (DISP_TABLE_P (w
->display_table
))
1466 dp
= XCHAR_TABLE (w
->display_table
);
1467 else if (BUFFERP (w
->buffer
))
1469 struct buffer
*b
= XBUFFER (w
->buffer
);
1471 if (DISP_TABLE_P (b
->display_table
))
1472 dp
= XCHAR_TABLE (b
->display_table
);
1473 else if (DISP_TABLE_P (Vstandard_display_table
))
1474 dp
= XCHAR_TABLE (Vstandard_display_table
);
1480 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1481 doc
: /* Set WINDOW's display-table to TABLE. */)
1483 register Lisp_Object window
, table
;
1485 register struct window
*w
;
1487 w
= decode_window (window
);
1488 w
->display_table
= table
;
1492 /* Record info on buffer window w is displaying
1493 when it is about to cease to display that buffer. */
1495 unshow_buffer (register struct window
*w
)
1502 if (b
!= XMARKER (w
->pointm
)->buffer
)
1506 if (w
== XWINDOW (selected_window
)
1507 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1508 /* Do this except when the selected window's buffer
1509 is being removed from some other window. */
1511 /* last_window_start records the start position that this buffer
1512 had in the last window to be disconnected from it.
1513 Now that this statement is unconditional,
1514 it is possible for the buffer to be displayed in the
1515 selected window, while last_window_start reflects another
1516 window which was recently showing the same buffer.
1517 Some people might say that might be a good thing. Let's see. */
1518 b
->last_window_start
= marker_position (w
->start
);
1520 /* Point in the selected window's buffer
1521 is actually stored in that buffer, and the window's pointm isn't used.
1522 So don't clobber point in that buffer. */
1523 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1524 /* This line helps to fix Horsley's testbug.el bug. */
1525 && !(WINDOWP (b
->last_selected_window
)
1526 && w
!= XWINDOW (b
->last_selected_window
)
1527 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1528 temp_set_point_both (b
,
1529 clip_to_bounds (BUF_BEGV (b
),
1530 XMARKER (w
->pointm
)->charpos
,
1532 clip_to_bounds (BUF_BEGV_BYTE (b
),
1533 marker_byte_position (w
->pointm
),
1536 if (WINDOWP (b
->last_selected_window
)
1537 && w
== XWINDOW (b
->last_selected_window
))
1538 b
->last_selected_window
= Qnil
;
1541 /* Put replacement into the window structure in place of old. */
1543 replace_window (Lisp_Object old
, Lisp_Object replacement
)
1545 register Lisp_Object tem
;
1546 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1548 /* If OLD is its frame's root_window, then replacement is the new
1549 root_window for that frame. */
1551 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1552 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1554 p
->left_col
= o
->left_col
;
1555 p
->top_line
= o
->top_line
;
1556 p
->total_cols
= o
->total_cols
;
1557 p
->total_lines
= o
->total_lines
;
1558 p
->desired_matrix
= p
->current_matrix
= 0;
1560 bzero (&p
->cursor
, sizeof (p
->cursor
));
1561 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1562 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1563 p
->phys_cursor_type
= -1;
1564 p
->phys_cursor_width
= -1;
1565 p
->must_be_updated_p
= 0;
1566 p
->pseudo_window_p
= 0;
1567 XSETFASTINT (p
->window_end_vpos
, 0);
1568 XSETFASTINT (p
->window_end_pos
, 0);
1569 p
->window_end_valid
= Qnil
;
1570 p
->frozen_window_start_p
= 0;
1571 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1573 p
->next
= tem
= o
->next
;
1575 XWINDOW (tem
)->prev
= replacement
;
1577 p
->prev
= tem
= o
->prev
;
1579 XWINDOW (tem
)->next
= replacement
;
1581 p
->parent
= tem
= o
->parent
;
1584 if (EQ (XWINDOW (tem
)->vchild
, old
))
1585 XWINDOW (tem
)->vchild
= replacement
;
1586 if (EQ (XWINDOW (tem
)->hchild
, old
))
1587 XWINDOW (tem
)->hchild
= replacement
;
1590 /*** Here, if replacement is a vertical combination
1591 and so is its new parent, we should make replacement's
1592 children be children of that parent instead. ***/
1595 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1596 doc
: /* Remove WINDOW from its frame.
1597 WINDOW defaults to the selected window. Return nil.
1598 Signal an error when WINDOW is the only window on its frame. */)
1600 register Lisp_Object window
;
1604 window
= selected_window
;
1606 CHECK_LIVE_WINDOW (window
);
1608 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1609 delete_window (window
);
1611 run_window_configuration_change_hook (f
);
1617 delete_window (register Lisp_Object window
)
1619 register Lisp_Object tem
, parent
, sib
;
1620 register struct window
*p
;
1621 register struct window
*par
;
1624 /* Because this function is called by other C code on non-leaf
1625 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1626 so we can't decode_window here. */
1627 CHECK_WINDOW (window
);
1628 p
= XWINDOW (window
);
1630 /* It's a no-op to delete an already-deleted window. */
1631 if (NILP (p
->buffer
)
1633 && NILP (p
->vchild
))
1638 error ("Attempt to delete minibuffer or sole ordinary window");
1639 par
= XWINDOW (parent
);
1641 windows_or_buffers_changed
++;
1642 Vwindow_list
= Qnil
;
1643 f
= XFRAME (WINDOW_FRAME (p
));
1644 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1646 /* Are we trying to delete any frame's selected window? */
1648 Lisp_Object swindow
, pwindow
;
1650 /* See if the frame's selected window is either WINDOW
1651 or any subwindow of it, by finding all that window's parents
1652 and comparing each one with WINDOW. */
1653 swindow
= FRAME_SELECTED_WINDOW (f
);
1658 while (!NILP (pwindow
))
1660 if (EQ (window
, pwindow
))
1662 pwindow
= XWINDOW (pwindow
)->parent
;
1665 /* If the window being deleted is not a parent of SWINDOW,
1666 then SWINDOW is ok as the new selected window. */
1667 if (!EQ (window
, pwindow
))
1669 /* Otherwise, try another window for SWINDOW. */
1670 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);
1672 /* If we get back to the frame's selected window,
1673 it means there was no acceptable alternative,
1674 so we cannot delete. */
1675 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1676 error ("Cannot delete window");
1679 /* If we need to change SWINDOW, do it. */
1680 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1682 /* If we're about to delete the selected window on the
1683 selected frame, then we should use Fselect_window to select
1684 the new window. On the other hand, if we're about to
1685 delete the selected window on any other frame, we shouldn't do
1686 anything but set the frame's selected_window slot. */
1687 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1688 Fselect_window (swindow
, Qnil
);
1690 FRAME_SELECTED_WINDOW (f
) = swindow
;
1694 /* Now we know we can delete this one. */
1695 window_deletion_count
++;
1698 /* tem is null for dummy parent windows
1699 (which have inferiors but not any contents themselves) */
1703 unchain_marker (XMARKER (p
->pointm
));
1704 unchain_marker (XMARKER (p
->start
));
1707 /* Free window glyph matrices. It is sure that they are allocated
1708 again when ADJUST_GLYPHS is called. Block input so that expose
1709 events and other events that access glyph matrices are not
1710 processed while we are changing them. */
1712 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1716 XWINDOW (tem
)->prev
= p
->prev
;
1720 XWINDOW (tem
)->next
= p
->next
;
1722 if (EQ (window
, par
->hchild
))
1723 par
->hchild
= p
->next
;
1724 if (EQ (window
, par
->vchild
))
1725 par
->vchild
= p
->next
;
1727 /* Find one of our siblings to give our space to. */
1731 /* If p gives its space to its next sibling, that sibling needs
1732 to have its top/left side pulled back to where p's is.
1733 set_window_{height,width} will re-position the sibling's
1736 XWINDOW (sib
)->top_line
= p
->top_line
;
1737 XWINDOW (sib
)->left_col
= p
->left_col
;
1740 /* Stretch that sibling. */
1741 if (!NILP (par
->vchild
))
1742 set_window_height (sib
,
1743 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1745 if (!NILP (par
->hchild
))
1746 set_window_width (sib
,
1747 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1750 /* If parent now has only one child,
1751 put the child into the parent's place. */
1755 if (NILP (XWINDOW (tem
)->next
)) {
1756 replace_window (parent
, tem
);
1757 par
= XWINDOW (tem
);
1760 /* Since we may be deleting combination windows, we must make sure that
1761 not only p but all its children have been marked as deleted. */
1762 if (! NILP (p
->hchild
))
1763 delete_all_subwindows (XWINDOW (p
->hchild
));
1764 else if (! NILP (p
->vchild
))
1765 delete_all_subwindows (XWINDOW (p
->vchild
));
1767 /* Mark this window as deleted. */
1768 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1770 if (! NILP (par
->parent
))
1771 par
= XWINDOW (par
->parent
);
1773 /* Check if we have a v/hchild with a v/hchild. In that case remove
1776 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1778 p
= XWINDOW (par
->vchild
);
1779 par
->vchild
= p
->vchild
;
1782 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1784 p
= XWINDOW (par
->hchild
);
1785 par
->hchild
= p
->hchild
;
1793 while (! NILP (tem
)) {
1794 XWINDOW (tem
)->parent
= p
->parent
;
1795 if (NILP (XWINDOW (tem
)->next
))
1797 tem
= XWINDOW (tem
)->next
;
1800 /* The next of the v/hchild we are removing is now the next of the
1801 last child for the v/hchild:
1802 Before v/hchild -> v/hchild -> next1 -> next2
1805 After: v/hchild -> next1 -> next2 -> next3
1807 XWINDOW (tem
)->next
= p
->next
;
1808 if (! NILP (p
->next
))
1809 XWINDOW (p
->next
)->prev
= tem
;
1811 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1815 /* Adjust glyph matrices. */
1822 /***********************************************************************
1824 ***********************************************************************/
1826 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1827 pointer. This is a callback function for foreach_window, used in
1828 function window_list. */
1831 add_window_to_list (struct window
*w
, void *user_data
)
1833 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1835 XSETWINDOW (window
, w
);
1836 *list
= Fcons (window
, *list
);
1841 /* Return a list of all windows, for use by next_window. If
1842 Vwindow_list is a list, return that list. Otherwise, build a new
1843 list, cache it in Vwindow_list, and return that. */
1848 if (!CONSP (Vwindow_list
))
1852 Vwindow_list
= Qnil
;
1853 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1855 Lisp_Object args
[2];
1857 /* We are visiting windows in canonical order, and add
1858 new windows at the front of args[1], which means we
1859 have to reverse this list at the end. */
1861 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1862 args
[0] = Vwindow_list
;
1863 args
[1] = Fnreverse (args
[1]);
1864 Vwindow_list
= Fnconc (2, args
);
1868 return Vwindow_list
;
1872 /* Value is non-zero if WINDOW satisfies the constraints given by
1873 OWINDOW, MINIBUF and ALL_FRAMES.
1875 MINIBUF t means WINDOW may be minibuffer windows.
1876 `lambda' means WINDOW may not be a minibuffer window.
1877 a window means a specific minibuffer window
1879 ALL_FRAMES t means search all frames,
1880 nil means search just current frame,
1881 `visible' means search just visible frames,
1882 0 means search visible and iconified frames,
1883 a window means search the frame that window belongs to,
1884 a frame means consider windows on that frame, only. */
1887 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
1889 struct window
*w
= XWINDOW (window
);
1890 struct frame
*f
= XFRAME (w
->frame
);
1891 int candidate_p
= 1;
1893 if (!BUFFERP (w
->buffer
))
1895 else if (MINI_WINDOW_P (w
)
1896 && (EQ (minibuf
, Qlambda
)
1897 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1899 /* If MINIBUF is `lambda' don't consider any mini-windows.
1900 If it is a window, consider only that one. */
1903 else if (EQ (all_frames
, Qt
))
1905 else if (NILP (all_frames
))
1907 xassert (WINDOWP (owindow
));
1908 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1910 else if (EQ (all_frames
, Qvisible
))
1912 FRAME_SAMPLE_VISIBILITY (f
);
1913 candidate_p
= FRAME_VISIBLE_P (f
)
1914 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1915 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1918 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1920 FRAME_SAMPLE_VISIBILITY (f
);
1921 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
1922 #ifdef HAVE_X_WINDOWS
1923 /* Yuck!! If we've just created the frame and the
1924 window-manager requested the user to place it
1925 manually, the window may still not be considered
1926 `visible'. I'd argue it should be at least
1927 something like `iconified', but don't know how to do
1929 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
1930 && !f
->output_data
.x
->has_been_visible
)
1933 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1934 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1936 else if (WINDOWP (all_frames
))
1937 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1938 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1939 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1940 else if (FRAMEP (all_frames
))
1941 candidate_p
= EQ (all_frames
, w
->frame
);
1947 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1948 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1952 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
1955 *window
= selected_window
;
1957 CHECK_LIVE_WINDOW (*window
);
1959 /* MINIBUF nil may or may not include minibuffers. Decide if it
1961 if (NILP (*minibuf
))
1962 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1963 else if (!EQ (*minibuf
, Qt
))
1966 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1967 => count none of them, or a specific minibuffer window (the
1968 active one) to count. */
1970 /* ALL_FRAMES nil doesn't specify which frames to include. */
1971 if (NILP (*all_frames
))
1972 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1973 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1975 else if (EQ (*all_frames
, Qvisible
))
1977 else if (EQ (*all_frames
, make_number (0)))
1979 else if (FRAMEP (*all_frames
))
1981 else if (!EQ (*all_frames
, Qt
))
1984 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1985 search just current frame, `visible' meaning search just visible
1986 frames, 0 meaning search visible and iconified frames, or a
1987 window, meaning search the frame that window belongs to, or a
1988 frame, meaning consider windows on that frame, only. */
1992 /* Return the next or previous window of WINDOW in cyclic ordering
1993 of windows. NEXT_P non-zero means return the next window. See the
1994 documentation string of next-window for the meaning of MINIBUF and
1998 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2000 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2002 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2003 return the first window on the frame. */
2004 if (FRAMEP (all_frames
)
2005 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2006 return Fframe_first_window (all_frames
);
2012 /* Find WINDOW in the list of all windows. */
2013 list
= Fmemq (window
, window_list ());
2015 /* Scan forward from WINDOW to the end of the window list. */
2017 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2018 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2021 /* Scan from the start of the window list up to WINDOW. */
2023 for (list
= Vwindow_list
;
2024 CONSP (list
) && !EQ (XCAR (list
), window
);
2026 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2030 window
= XCAR (list
);
2034 Lisp_Object candidate
, list
;
2036 /* Scan through the list of windows for candidates. If there are
2037 candidate windows in front of WINDOW, the last one of these
2038 is the one we want. If there are candidates following WINDOW
2039 in the list, again the last one of these is the one we want. */
2041 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2043 if (EQ (XCAR (list
), window
))
2045 if (WINDOWP (candidate
))
2048 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2050 candidate
= XCAR (list
);
2053 if (WINDOWP (candidate
))
2061 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2062 doc
: /* Return window following WINDOW in cyclic ordering of windows.
2063 WINDOW defaults to the selected window. The optional arguments
2064 MINIBUF and ALL-FRAMES specify the set of windows to consider.
2066 MINIBUF t means consider the minibuffer window even if the
2067 minibuffer is not active. MINIBUF nil or omitted means consider
2068 the minibuffer window only if the minibuffer is active. Any
2069 other value means do not consider the minibuffer window even if
2070 the minibuffer is active.
2072 Several frames may share a single minibuffer; if the minibuffer
2073 is active, all windows on all frames that share that minibuffer
2074 are considered too. Therefore, if you are using a separate
2075 minibuffer frame and the minibuffer is active and MINIBUF says it
2076 counts, `next-window' considers the windows in the frame from
2077 which you entered the minibuffer, as well as the minibuffer
2080 ALL-FRAMES nil or omitted means consider all windows on WINDOW's
2081 frame, plus the minibuffer window if specified by the MINIBUF
2082 argument, see above. If the minibuffer counts, consider all
2083 windows on all frames that share that minibuffer too.
2084 ALL-FRAMES t means consider all windows on all existing frames.
2085 ALL-FRAMES `visible' means consider all windows on all visible
2087 ALL-FRAMES 0 means consider all windows on all visible and
2089 ALL-FRAMES a frame means consider all windows on that frame only.
2090 Anything else means consider all windows on WINDOW's frame and no
2093 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2094 `next-window' to iterate through the entire cycle of acceptable
2095 windows, eventually ending up back at the window you started with.
2096 `previous-window' traverses the same cycle, in the reverse order. */)
2097 (window
, minibuf
, all_frames
)
2098 Lisp_Object window
, minibuf
, all_frames
;
2100 return next_window (window
, minibuf
, all_frames
, 1);
2104 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2105 doc
: /* Return window preceding WINDOW in cyclic ordering of windows.
2106 WINDOW defaults to the selected window. The optional arguments
2107 MINIBUF and ALL-FRAMES specify the set of windows to consider.
2108 For the precise meaning of these arguments see `next-window'.
2110 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2111 use `previous-window' to iterate through the entire cycle of
2112 acceptable windows, eventually ending up back at the window you
2113 started with. `next-window' traverses the same cycle, in the
2115 (window
, minibuf
, all_frames
)
2116 Lisp_Object window
, minibuf
, all_frames
;
2118 return next_window (window
, minibuf
, all_frames
, 0);
2122 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
2123 doc
: /* Select another window in cyclic ordering of windows.
2124 COUNT specifies the number of windows to skip, starting with the
2125 selected window, before making the selection. If COUNT is
2126 positive, skip COUNT windows forwards. If COUNT is negative,
2127 skip -COUNT windows backwards. COUNT zero means do not skip any
2128 window, so select the selected window. In an interactive call,
2129 COUNT is the numeric prefix argument. Return nil.
2131 This function uses `next-window' for finding the window to select.
2132 The argument ALL-FRAMES has the same meaning as in `next-window',
2133 but the MINIBUF argument of `next-window' is always effectively
2136 Lisp_Object count
, all_frames
;
2141 CHECK_NUMBER (count
);
2142 window
= selected_window
;
2144 for (i
= XINT (count
); i
> 0; --i
)
2145 window
= Fnext_window (window
, Qnil
, all_frames
);
2147 window
= Fprevious_window (window
, Qnil
, all_frames
);
2149 Fselect_window (window
, Qnil
);
2154 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2155 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2156 FRAME nil or omitted means use the selected frame.
2157 WINDOW nil or omitted means use the selected window.
2158 MINIBUF t means include the minibuffer window, even if it isn't active.
2159 MINIBUF nil or omitted means include the minibuffer window only
2161 MINIBUF neither nil nor t means never include the minibuffer window. */)
2162 (frame
, minibuf
, window
)
2163 Lisp_Object frame
, minibuf
, window
;
2166 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2167 CHECK_WINDOW (window
);
2169 frame
= selected_frame
;
2171 if (!EQ (frame
, XWINDOW (window
)->frame
))
2172 error ("Window is on a different frame");
2174 return window_list_1 (window
, minibuf
, frame
);
2178 /* Return a list of windows in cyclic ordering. Arguments are like
2179 for `next-window'. */
2182 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2184 Lisp_Object tail
, list
, rest
;
2186 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2189 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2190 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2191 list
= Fcons (XCAR (tail
), list
);
2193 /* Rotate the list to start with WINDOW. */
2194 list
= Fnreverse (list
);
2195 rest
= Fmemq (window
, list
);
2196 if (!NILP (rest
) && !EQ (rest
, list
))
2198 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2200 XSETCDR (tail
, Qnil
);
2201 list
= nconc2 (rest
, list
);
2208 /* Look at all windows, performing an operation specified by TYPE
2210 If FRAMES is Qt, look at all frames;
2211 Qnil, look at just the selected frame;
2212 Qvisible, look at visible frames;
2213 a frame, just look at windows on that frame.
2214 If MINI is non-zero, perform the operation on minibuffer windows too. */
2219 GET_BUFFER_WINDOW
, /* Arg is buffer */
2220 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2221 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2222 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2224 UNSHOW_BUFFER
, /* Arg is buffer */
2225 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2230 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2232 Lisp_Object window
, windows
, best_window
, frame_arg
;
2234 struct gcpro gcpro1
;
2236 /* If we're only looping through windows on a particular frame,
2237 frame points to that frame. If we're looping through windows
2238 on all frames, frame is 0. */
2239 if (FRAMEP (frames
))
2240 f
= XFRAME (frames
);
2241 else if (NILP (frames
))
2242 f
= SELECTED_FRAME ();
2247 frame_arg
= Qlambda
;
2248 else if (EQ (frames
, make_number (0)))
2250 else if (EQ (frames
, Qvisible
))
2255 /* frame_arg is Qlambda to stick to one frame,
2256 Qvisible to consider all visible frames,
2259 /* Pick a window to start with. */
2263 window
= FRAME_SELECTED_WINDOW (f
);
2265 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2267 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2271 for (; CONSP (windows
); windows
= XCDR (windows
))
2275 window
= XCAR (windows
);
2276 w
= XWINDOW (window
);
2278 /* Note that we do not pay attention here to whether the frame
2279 is visible, since Fwindow_list skips non-visible frames if
2280 that is desired, under the control of frame_arg. */
2281 if (!MINI_WINDOW_P (w
)
2282 /* For UNSHOW_BUFFER, we must always consider all windows. */
2283 || type
== UNSHOW_BUFFER
2284 || (mini
&& minibuf_level
> 0))
2287 case GET_BUFFER_WINDOW
:
2288 if (EQ (w
->buffer
, obj
)
2289 /* Don't find any minibuffer window
2290 except the one that is currently in use. */
2291 && (MINI_WINDOW_P (w
)
2292 ? EQ (window
, minibuf_window
)
2295 if (NILP (best_window
))
2296 best_window
= window
;
2297 else if (EQ (window
, selected_window
))
2298 /* Prefer to return selected-window. */
2299 RETURN_UNGCPRO (window
);
2300 else if (EQ (Fwindow_frame (window
), selected_frame
))
2301 /* Prefer windows on the current frame. */
2302 best_window
= window
;
2306 case GET_LRU_WINDOW
:
2307 /* `obj' is an integer encoding a bitvector.
2308 `obj & 1' means consider only full-width windows.
2309 `obj & 2' means consider also dedicated windows. */
2310 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2311 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2312 /* Minibuffer windows are always ignored. */
2313 || MINI_WINDOW_P (w
))
2315 if (NILP (best_window
)
2316 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2317 > XFASTINT (w
->use_time
)))
2318 best_window
= window
;
2321 case DELETE_OTHER_WINDOWS
:
2322 if (!EQ (window
, obj
))
2323 Fdelete_window (window
);
2326 case DELETE_BUFFER_WINDOWS
:
2327 if (EQ (w
->buffer
, obj
))
2329 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2331 /* If this window is dedicated, and in a frame of its own,
2333 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2334 && !NILP (w
->dedicated
)
2335 && other_visible_frames (f
))
2337 /* Skip the other windows on this frame.
2338 There might be one, the minibuffer! */
2339 while (CONSP (XCDR (windows
))
2340 && EQ (XWINDOW (XCAR (windows
))->frame
,
2341 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2342 windows
= XCDR (windows
);
2344 /* Now we can safely delete the frame. */
2345 delete_frame (w
->frame
, Qnil
);
2347 else if (NILP (w
->parent
))
2349 /* If we're deleting the buffer displayed in the
2350 only window on the frame, find a new buffer to
2353 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2354 /* Reset dedicated state of window. */
2355 w
->dedicated
= Qnil
;
2356 Fset_window_buffer (window
, buffer
, Qnil
);
2357 if (EQ (window
, selected_window
))
2358 Fset_buffer (w
->buffer
);
2361 Fdelete_window (window
);
2365 case GET_LARGEST_WINDOW
:
2366 { /* nil `obj' means to ignore dedicated windows. */
2367 /* Ignore dedicated windows and minibuffers. */
2368 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2371 if (NILP (best_window
))
2372 best_window
= window
;
2375 struct window
*b
= XWINDOW (best_window
);
2376 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2377 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2378 best_window
= window
;
2384 if (EQ (w
->buffer
, obj
))
2387 struct frame
*f
= XFRAME (w
->frame
);
2389 /* Find another buffer to show in this window. */
2390 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2392 /* If this window is dedicated, and in a frame of its own,
2394 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2395 && !NILP (w
->dedicated
)
2396 && other_visible_frames (f
))
2398 /* Skip the other windows on this frame.
2399 There might be one, the minibuffer! */
2400 while (CONSP (XCDR (windows
))
2401 && EQ (XWINDOW (XCAR (windows
))->frame
,
2402 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2403 windows
= XCDR (windows
);
2405 /* Now we can safely delete the frame. */
2406 delete_frame (w
->frame
, Qnil
);
2408 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2411 XSETWINDOW (window
, w
);
2412 /* If this window is dedicated and not the only window
2413 in its frame, then kill it. */
2414 Fdelete_window (window
);
2418 /* Otherwise show a different buffer in the window. */
2419 w
->dedicated
= Qnil
;
2420 Fset_window_buffer (window
, buffer
, Qnil
);
2421 if (EQ (window
, selected_window
))
2422 Fset_buffer (w
->buffer
);
2427 case REDISPLAY_BUFFER_WINDOWS
:
2428 if (EQ (w
->buffer
, obj
))
2430 mark_window_display_accurate (window
, 0);
2431 w
->update_mode_line
= Qt
;
2432 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2433 ++update_mode_lines
;
2434 best_window
= window
;
2438 /* Check for a window that has a killed buffer. */
2439 case CHECK_ALL_WINDOWS
:
2440 if (! NILP (w
->buffer
)
2441 && NILP (XBUFFER (w
->buffer
)->name
))
2445 case WINDOW_LOOP_UNUSED
:
2454 /* Used for debugging. Abort if any window has a dead buffer. */
2457 check_all_windows (void)
2459 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2462 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2463 doc
: /* Return the window least recently selected or used for display.
2464 \(LRU means Least Recently Used.)
2466 Return a full-width window if possible.
2467 A minibuffer window is never a candidate.
2468 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2469 so if all windows are dedicated, the value is nil.
2470 If optional argument FRAME is `visible', search all visible frames.
2471 If FRAME is 0, search all visible and iconified frames.
2472 If FRAME is t, search all frames.
2473 If FRAME is nil, search only the selected frame.
2474 If FRAME is a frame, search only that frame. */)
2476 Lisp_Object frame
, dedicated
;
2478 register Lisp_Object w
;
2479 /* First try for a window that is full-width */
2480 w
= window_loop (GET_LRU_WINDOW
,
2481 NILP (dedicated
) ? make_number (1) : make_number (3),
2483 if (!NILP (w
) && !EQ (w
, selected_window
))
2485 /* If none of them, try the rest */
2486 return window_loop (GET_LRU_WINDOW
,
2487 NILP (dedicated
) ? make_number (0) : make_number (2),
2491 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2492 doc
: /* Return the largest window in area.
2493 A minibuffer window is never a candidate.
2494 A dedicated window is never a candidate unless DEDICATED is non-nil,
2495 so if all windows are dedicated, the value is nil.
2496 If optional argument FRAME is `visible', search all visible frames.
2497 If FRAME is 0, search all visible and iconified frames.
2498 If FRAME is t, search all frames.
2499 If FRAME is nil, search only the selected frame.
2500 If FRAME is a frame, search only that frame. */)
2502 Lisp_Object frame
, dedicated
;
2504 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2508 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2509 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2510 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to the
2512 If optional argument FRAME is `visible', search all visible frames.
2513 If optional argument FRAME is 0, search all visible and iconified frames.
2514 If FRAME is t, search all frames.
2515 If FRAME is nil, search only the selected frame.
2516 If FRAME is a frame, search only that frame. */)
2517 (buffer_or_name
, frame
)
2518 Lisp_Object buffer_or_name
, frame
;
2522 if (NILP (buffer_or_name
))
2523 buffer
= Fcurrent_buffer ();
2525 buffer
= Fget_buffer (buffer_or_name
);
2527 if (BUFFERP (buffer
))
2528 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2533 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2535 doc
: /* Make WINDOW (or the selected window) fill its frame.
2536 Only the frame WINDOW is on is affected.
2537 This function tries to reduce display jumps by keeping the text
2538 previously visible in WINDOW in the same place on the frame. Doing this
2539 depends on the value of (window-start WINDOW), so if calling this
2540 function in a program gives strange scrolling, make sure the
2541 window-start value is reasonable when this function is called. */)
2550 window
= selected_window
;
2552 CHECK_LIVE_WINDOW (window
);
2553 w
= XWINDOW (window
);
2555 startpos
= marker_position (w
->start
);
2556 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2558 if (MINI_WINDOW_P (w
) && top
> 0)
2559 error ("Can't expand minibuffer to full frame");
2561 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2563 /* Try to minimize scrolling, by setting the window start to the point
2564 will cause the text at the old window start to be at the same place
2565 on the frame. But don't try to do this if the window start is
2566 outside the visible portion (as might happen when the display is
2567 not current, due to typeahead). */
2568 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2570 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2571 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2573 struct position pos
;
2574 struct buffer
*obuf
= current_buffer
;
2576 Fset_buffer (w
->buffer
);
2577 /* This computation used to temporarily move point, but that can
2578 have unwanted side effects due to text properties. */
2579 pos
= *vmotion (startpos
, -top
, w
);
2581 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2582 w
->window_end_valid
= Qnil
;
2583 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2584 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2586 /* We need to do this, so that the window-scroll-functions
2588 w
->optional_new_start
= Qt
;
2590 set_buffer_internal (obuf
);
2596 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2597 0, 2, "bDelete windows on (buffer): ",
2598 doc
: /* Delete all windows showing BUFFER-OR-NAME.
2599 BUFFER-OR-NAME may be a buffer or the name of an existing buffer and
2600 defaults to the current buffer.
2602 Optional second argument FRAME controls which frames are affected.
2603 If optional argument FRAME is `visible', search all visible frames.
2604 If FRAME is 0, search all visible and iconified frames.
2605 If FRAME is nil, search all frames.
2606 If FRAME is t, search only the selected frame.
2607 If FRAME is a frame, search only that frame.
2608 When a window showing BUFFER-OR-NAME is dedicated and the only window of
2609 its frame, that frame is deleted when there are other frames left. */)
2610 (buffer_or_name
, frame
)
2611 Lisp_Object buffer_or_name
, frame
;
2615 /* FRAME uses t and nil to mean the opposite of what window_loop
2619 else if (EQ (frame
, Qt
))
2622 if (NILP (buffer_or_name
))
2623 buffer
= Fcurrent_buffer ();
2626 buffer
= Fget_buffer (buffer_or_name
);
2627 CHECK_BUFFER (buffer
);
2630 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2635 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2636 Sreplace_buffer_in_windows
,
2637 0, 1, "bReplace buffer in windows: ",
2638 doc
: /* Replace BUFFER-OR-NAME with some other buffer in all windows showing it.
2639 BUFFER-OR-NAME may be a buffer or the name of an existing buffer and
2640 defaults to the current buffer.
2642 When a window showing BUFFER-OR-NAME is dedicated that window is
2643 deleted. If that window is the only window on its frame, that frame is
2644 deleted too when there are other frames left. If there are no other
2645 frames left, some other buffer is displayed in that window. */)
2647 Lisp_Object buffer_or_name
;
2651 if (NILP (buffer_or_name
))
2652 buffer
= Fcurrent_buffer ();
2655 buffer
= Fget_buffer (buffer_or_name
);
2656 CHECK_BUFFER (buffer
);
2659 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2664 /* Replace BUFFER with some other buffer in all windows
2665 of all frames, even those on other keyboards. */
2668 replace_buffer_in_all_windows (Lisp_Object buffer
)
2670 Lisp_Object tail
, frame
;
2672 /* A single call to window_loop won't do the job
2673 because it only considers frames on the current keyboard.
2674 So loop manually over frames, and handle each one. */
2675 FOR_EACH_FRAME (tail
, frame
)
2676 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2679 /* Set the height of WINDOW and all its inferiors. */
2681 /* The smallest acceptable dimensions for a window. Anything smaller
2682 might crash Emacs. */
2684 #define MIN_SAFE_WINDOW_WIDTH (2)
2685 #define MIN_SAFE_WINDOW_HEIGHT (1)
2687 /* For wp non-zero the total number of columns of window w. Otherwise
2688 the total number of lines of w. */
2690 #define WINDOW_TOTAL_SIZE(w, wp) \
2691 (wp ? WINDOW_TOTAL_COLS (w) : WINDOW_TOTAL_LINES (w))
2693 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2694 minimum allowable size. */
2697 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2699 /* For height, we have to see:
2700 how many windows the frame has at minimum (one or two),
2701 and whether it has a menu bar or other special stuff at the top. */
2703 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2704 ? MIN_SAFE_WINDOW_HEIGHT
2705 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2707 if (FRAME_TOP_MARGIN (frame
) > 0)
2708 min_height
+= FRAME_TOP_MARGIN (frame
);
2710 if (*rows
< min_height
)
2712 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2713 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2716 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2717 check if W's width can be changed, otherwise check W's height.
2718 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2719 siblings, too. If none of the siblings is resizable, WINDOW isn't
2723 window_fixed_size_p (struct window
*w
, int width_p
, int check_siblings_p
)
2728 if (!NILP (w
->hchild
))
2730 c
= XWINDOW (w
->hchild
);
2734 /* A horizontal combination is fixed-width if all of if its
2736 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2737 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2738 fixed_p
= c
== NULL
;
2742 /* A horizontal combination is fixed-height if one of if its
2744 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2745 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2746 fixed_p
= c
!= NULL
;
2749 else if (!NILP (w
->vchild
))
2751 c
= XWINDOW (w
->vchild
);
2755 /* A vertical combination is fixed-width if one of if its
2757 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2758 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2759 fixed_p
= c
!= NULL
;
2763 /* A vertical combination is fixed-height if all of if its
2765 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2766 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2767 fixed_p
= c
== NULL
;
2770 else if (BUFFERP (w
->buffer
))
2772 struct buffer
*old
= current_buffer
;
2775 current_buffer
= XBUFFER (w
->buffer
);
2776 val
= find_symbol_value (Qwindow_size_fixed
);
2777 current_buffer
= old
;
2780 if (!EQ (val
, Qunbound
))
2782 fixed_p
= !NILP (val
);
2785 && ((EQ (val
, Qheight
) && width_p
)
2786 || (EQ (val
, Qwidth
) && !width_p
)))
2790 /* Can't tell if this one is resizable without looking at
2791 siblings. If all siblings are fixed-size this one is too. */
2792 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2796 for (child
= w
->prev
; WINDOWP (child
); child
= XWINDOW (child
)->prev
)
2797 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2801 for (child
= w
->next
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
2802 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2815 /* Return minimum size of leaf window W. WIDTH_P non-zero means return
2816 the minimum width of W, WIDTH_P zero means return the minimum height
2817 of W. SAFE_P non-zero means ignore window-min-height|width but just
2818 return values that won't crash Emacs and don't hide components like
2819 fringes, scrollbars, or modelines. If WIDTH_P is zero and W is the
2820 minibuffer window, always return 1. */
2823 window_min_size_2 (struct window
*w
, int width_p
, int safe_p
)
2825 /* We should consider buffer-local values of window_min_height and
2826 window_min_width here. */
2829 int safe_size
= (MIN_SAFE_WINDOW_WIDTH
2830 + WINDOW_FRINGE_COLS (w
)
2831 + WINDOW_SCROLL_BAR_COLS (w
));
2833 return safe_p
? safe_size
: max (window_min_width
, safe_size
);
2835 else if (MINI_WINDOW_P (w
))
2839 int safe_size
= (MIN_SAFE_WINDOW_HEIGHT
2840 + ((BUFFERP (w
->buffer
)
2841 && !NILP (XBUFFER (w
->buffer
)->mode_line_format
))
2844 return safe_p
? safe_size
: max (window_min_height
, safe_size
);
2848 /* Return minimum size of window W, not taking fixed-width windows into
2849 account. WIDTH_P non-zero means return the minimum width, otherwise
2850 return the minimum height. SAFE_P non-zero means ignore
2851 window-min-height|width but just return values that won't crash Emacs
2852 and don't hide components like fringes, scrollbars, or modelines. If
2853 W is a combination window, compute the minimum size from the minimum
2854 sizes of W's children. */
2857 window_min_size_1 (struct window
*w
, int width_p
, int safe_p
)
2862 if (!NILP (w
->hchild
))
2864 /* W is a horizontal combination. */
2865 c
= XWINDOW (w
->hchild
);
2870 /* The minimum width of a horizontal combination is the sum of
2871 the minimum widths of its children. */
2874 size
+= window_min_size_1 (c
, 1, safe_p
);
2875 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2880 /* The minimum height of a horizontal combination is the
2881 maximum of the minimum heights of its children. */
2884 size
= max (window_min_size_1 (c
, 0, safe_p
), size
);
2885 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2889 else if (!NILP (w
->vchild
))
2891 /* W is a vertical combination. */
2892 c
= XWINDOW (w
->vchild
);
2897 /* The minimum width of a vertical combination is the maximum
2898 of the minimum widths of its children. */
2901 size
= max (window_min_size_1 (c
, 1, safe_p
), size
);
2902 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2907 /* The minimum height of a vertical combination is the sum of
2908 the minimum height of its children. */
2911 size
+= window_min_size_1 (c
, 0, safe_p
);
2912 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2917 /* W is a leaf window. */
2918 size
= window_min_size_2 (w
, width_p
, safe_p
);
2923 /* Return the minimum size of window W, taking fixed-size windows into
2924 account. WIDTH_P non-zero means return the minimum width, otherwise
2925 return the minimum height. SAFE_P non-zero means ignore
2926 window-min-height|width but just return values that won't crash Emacs
2927 and don't hide components like fringes, scrollbars, or modelines.
2928 IGNORE_FIXED_P non-zero means ignore if W is fixed-size. Set *FIXED
2929 to 1 if W is fixed-size unless FIXED is null. */
2932 window_min_size (struct window
*w
, int width_p
, int safe_p
, int ignore_fixed_p
, int *fixed
)
2939 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2945 size
= WINDOW_TOTAL_SIZE (w
, width_p
);
2947 size
= window_min_size_1 (w
, width_p
, safe_p
);
2953 /* Adjust the margins of window W if text area is too small.
2954 Return 1 if window width is ok after adjustment; 0 if window
2955 is still too narrow. */
2958 adjust_window_margins (struct window
*w
)
2960 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2961 - WINDOW_FRINGE_COLS (w
)
2962 - WINDOW_SCROLL_BAR_COLS (w
));
2963 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2964 + WINDOW_RIGHT_MARGIN_COLS (w
));
2966 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2969 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2972 /* Window's text area is too narrow, but reducing the window
2973 margins will fix that. */
2974 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2975 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2977 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2978 w
->left_margin_cols
= w
->right_margin_cols
2979 = make_number (margin_cols
/2);
2981 w
->right_margin_cols
= make_number (margin_cols
);
2984 w
->left_margin_cols
= make_number (margin_cols
);
2988 /* Calculate new sizes for windows in the list FORWARD when their
2989 compound size goes from TOTAL to SIZE. TOTAL must be greater than
2990 SIZE. The number of windows in FORWARD is NCHILDREN, and the number
2991 that can shrink is SHRINKABLE. Fixed-size windows may be shrunk if
2992 and only if RESIZE_FIXED_P is non-zero. WIDTH_P non-zero means
2993 shrink columns, otherwise shrink lines.
2995 SAFE_P zero means windows may be sized down to window-min-height
2996 lines (window-min-window columns for WIDTH_P non-zero). SAFE_P
2997 non-zero means windows may be sized down to their minimum safe sizes
2998 taking into account the space needed to display modelines, fringes,
3001 This function returns an allocated array of new sizes that the caller
3002 must free. A size -1 means the window is fixed and RESIZE_FIXED_P is
3003 zero. A size zero means the window shall be deleted. Array index 0
3004 refers to the first window in FORWARD, 1 to the second, and so on.
3006 This function resizes windows proportionally to their size. It also
3007 tries to preserve smaller windows by resizing larger windows before
3008 resizing any window to zero. If resize_proportionally is non-nil for
3009 a specific window, it will attempt to strictly resize that window
3010 proportionally, even at the expense of deleting smaller windows. */
3012 shrink_windows (int total
, int size
, int nchildren
, int shrinkable
,
3013 int resize_fixed_p
, Lisp_Object forward
, int width_p
, int safe_p
)
3015 int available_resize
= 0;
3016 int *new_sizes
, *min_sizes
;
3019 int smallest
= total
;
3020 int total_removed
= 0;
3021 int total_shrink
= total
- size
;
3024 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
3025 min_sizes
= xmalloc (sizeof (*min_sizes
) * nchildren
);
3027 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
3031 c
= XWINDOW (child
);
3032 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3034 if (!resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
3038 new_sizes
[i
] = child_size
;
3039 min_sizes
[i
] = window_min_size_1 (c
, width_p
, safe_p
);
3040 if (child_size
> min_sizes
[i
]
3041 && NILP (c
->resize_proportionally
))
3042 available_resize
+= child_size
- min_sizes
[i
];
3045 /* We might need to shrink some windows to zero. Find the smallest
3046 windows and set them to 0 until we can fulfil the new size. */
3048 while (shrinkable
> 1 && size
+ available_resize
< total
)
3050 for (i
= 0; i
< nchildren
; ++i
)
3051 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
3052 smallest
= new_sizes
[i
];
3054 for (i
= 0; i
< nchildren
; ++i
)
3055 if (new_sizes
[i
] == smallest
)
3057 /* Resize this window down to zero. */
3059 if (smallest
> min_sizes
[i
])
3060 available_resize
-= smallest
- min_sizes
[i
];
3061 available_resize
+= smallest
;
3063 total_removed
+= smallest
;
3065 /* We don't know what the smallest is now. */
3068 /* Out of for, just remove one window at the time and
3069 check again if we have enough space. */
3074 /* Now, calculate the new sizes. Try to shrink each window
3075 proportional to its size. */
3076 for (i
= 0; i
< nchildren
; ++i
)
3078 if (new_sizes
[i
] > min_sizes
[i
])
3080 int to_shrink
= total_shrink
* new_sizes
[i
] / total
;
3082 if (new_sizes
[i
] - to_shrink
< min_sizes
[i
])
3083 to_shrink
= new_sizes
[i
] - min_sizes
[i
];
3084 new_sizes
[i
] -= to_shrink
;
3085 total_removed
+= to_shrink
;
3089 /* Any reminder due to rounding, we just subtract from windows
3090 that are left and still can be shrunk. */
3091 while (total_shrink
> total_removed
)
3093 int nonzero_sizes
= 0;
3094 int nonzero_idx
= -1;
3096 for (i
= 0; i
< nchildren
; ++i
)
3097 if (new_sizes
[i
] > 0)
3103 for (i
= 0; i
< nchildren
; ++i
)
3104 if (new_sizes
[i
] > min_sizes
[i
])
3109 /* Out of for, just shrink one window at the time and
3110 check again if we have enough space. */
3114 /* Special case, only one window left. */
3115 if (nonzero_sizes
== 1)
3119 /* Any surplus due to rounding, we add to windows that are left. */
3120 while (total_shrink
< total_removed
)
3122 for (i
= 0; i
< nchildren
; ++i
)
3124 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
3138 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
3139 WINDOW's width. Resize WINDOW's children, if any, so that they keep
3140 their proportionate size relative to WINDOW.
3142 If FIRST_ONLY is 1, change only the first of WINDOW's children when
3143 they are in series. If LAST_ONLY is 1, change only the last of
3144 WINDOW's children when they are in series.
3146 Propagate WINDOW's top or left edge position to children. Delete
3147 windows that become too small unless NODELETE_P is 1. When
3148 NODELETE_P equals 2 do not honor settings for window-min-height and
3149 window-min-width when resizing windows but use safe defaults instead.
3150 This should give better behavior when resizing frames. */
3153 size_window (Lisp_Object window
, int size
, int width_p
, int nodelete_p
, int first_only
, int last_only
)
3155 struct window
*w
= XWINDOW (window
);
3157 Lisp_Object child
, *forward
, *sideward
;
3158 int old_size
= WINDOW_TOTAL_SIZE (w
, width_p
);
3160 size
= max (0, size
);
3162 /* Delete WINDOW if it's too small. */
3163 if (nodelete_p
!= 1 && !NILP (w
->parent
)
3164 && size
< window_min_size_1 (w
, width_p
, nodelete_p
== 2))
3166 delete_window (window
);
3170 /* Set redisplay hints. */
3171 w
->last_modified
= make_number (0);
3172 w
->last_overlay_modified
= make_number (0);
3173 windows_or_buffers_changed
++;
3174 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3178 sideward
= &w
->vchild
;
3179 forward
= &w
->hchild
;
3180 w
->total_cols
= make_number (size
);
3181 adjust_window_margins (w
);
3185 sideward
= &w
->hchild
;
3186 forward
= &w
->vchild
;
3187 w
->total_lines
= make_number (size
);
3188 w
->orig_total_lines
= Qnil
;
3191 if (!NILP (*sideward
))
3193 /* We have a chain of parallel siblings whose size should all change. */
3194 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3196 c
= XWINDOW (child
);
3198 c
->left_col
= w
->left_col
;
3200 c
->top_line
= w
->top_line
;
3201 size_window (child
, size
, width_p
, nodelete_p
,
3202 first_only
, last_only
);
3205 else if (!NILP (*forward
) && last_only
)
3207 /* Change the last in a series of siblings. */
3208 Lisp_Object last_child
;
3211 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3213 c
= XWINDOW (child
);
3217 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3218 size_window (last_child
, size
- old_size
+ child_size
,
3219 width_p
, nodelete_p
, first_only
, last_only
);
3221 else if (!NILP (*forward
) && first_only
)
3223 /* Change the first in a series of siblings. */
3227 c
= XWINDOW (child
);
3230 c
->left_col
= w
->left_col
;
3232 c
->top_line
= w
->top_line
;
3234 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3235 size_window (child
, size
- old_size
+ child_size
,
3236 width_p
, nodelete_p
, first_only
, last_only
);
3238 else if (!NILP (*forward
))
3240 int fixed_size
, each
, extra
, n
;
3241 int resize_fixed_p
, nfixed
;
3242 int last_pos
, first_pos
, nchildren
, total
;
3243 int *new_sizes
= NULL
;
3245 /* Determine the fixed-size portion of this window, and the
3246 number of child windows. */
3247 fixed_size
= nchildren
= nfixed
= total
= 0;
3248 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3252 c
= XWINDOW (child
);
3253 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3254 total
+= child_size
;
3256 if (window_fixed_size_p (c
, width_p
, 0))
3258 fixed_size
+= child_size
;
3263 /* If the new size is smaller than fixed_size, or if there
3264 aren't any resizable windows, allow resizing fixed-size
3266 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3268 /* Compute how many lines/columns to add/remove to each child. The
3269 value of extra takes care of rounding errors. */
3270 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3271 if (size
< total
&& n
> 1)
3272 new_sizes
= shrink_windows (total
, size
, nchildren
, n
,
3273 resize_fixed_p
, *forward
, width_p
,
3277 each
= (size
- total
) / n
;
3278 extra
= (size
- total
) - n
* each
;
3281 /* Compute new children heights and edge positions. */
3282 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3283 last_pos
= first_pos
;
3284 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3286 int new_size
, old_size
;
3288 c
= XWINDOW (child
);
3289 old_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3290 new_size
= old_size
;
3292 /* The top or left edge position of this child equals the
3293 bottom or right edge of its predecessor. */
3295 c
->left_col
= make_number (last_pos
);
3297 c
->top_line
= make_number (last_pos
);
3299 /* If this child can be resized, do it. */
3300 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3302 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3306 /* Set new size. Note that size_window also propagates
3307 edge positions to children, so it's not a no-op if we
3308 didn't change the child's size. */
3309 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3311 /* Remember the bottom/right edge position of this child; it
3312 will be used to set the top/left edge of the next child. */
3313 last_pos
+= new_size
;
3318 /* We should have covered the parent exactly with child windows. */
3319 xassert (size
== last_pos
- first_pos
);
3321 /* Now delete any children that became too small. */
3322 if (nodelete_p
!= 1)
3323 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3327 c
= XWINDOW (child
);
3328 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3329 size_window (child
, child_size
, width_p
, nodelete_p
,
3330 first_only
, last_only
);
3335 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3336 WINDOW's children. NODELETE zero means windows that have become
3337 smaller than window-min-height in the process may be deleted.
3338 NODELETE 1 means never delete windows that become too small in the
3339 process. (The caller should check later and do so if appropriate.)
3340 NODELETE 2 means delete only windows that have become too small to be
3341 displayed correctly. */
3344 set_window_height (Lisp_Object window
, int height
, int nodelete
)
3346 size_window (window
, height
, 0, nodelete
, 0, 0);
3349 /* Set WINDOW's width to WIDTH, and recursively change the width of
3350 WINDOW's children. NODELETE zero means windows that have become
3351 smaller than window-min-width in the process may be deleted.
3352 NODELETE 1 means never delete windows that become too small in the
3353 process. (The caller should check later and do so if appropriate.)
3354 NODELETE 2 means delete only windows that have become too small to be
3355 displayed correctly. */
3358 set_window_width (Lisp_Object window
, int width
, int nodelete
)
3360 size_window (window
, width
, 1, nodelete
, 0, 0);
3363 /* Change window heights in windows rooted in WINDOW by N lines. */
3366 change_window_heights (Lisp_Object window
, int n
)
3368 struct window
*w
= XWINDOW (window
);
3370 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3371 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3373 if (INTEGERP (w
->orig_top_line
))
3374 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3375 if (INTEGERP (w
->orig_total_lines
))
3376 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3378 /* Handle just the top child in a vertical split. */
3379 if (!NILP (w
->vchild
))
3380 change_window_heights (w
->vchild
, n
);
3382 /* Adjust all children in a horizontal split. */
3383 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3385 w
= XWINDOW (window
);
3386 change_window_heights (window
, n
);
3391 int window_select_count
;
3393 EXFUN (Fset_window_fringes
, 4);
3394 EXFUN (Fset_window_scroll_bars
, 4);
3397 run_funs (Lisp_Object funs
)
3399 for (; CONSP (funs
); funs
= XCDR (funs
))
3400 if (!EQ (XCAR (funs
), Qt
))
3401 call0 (XCAR (funs
));
3404 static Lisp_Object
select_window_norecord (Lisp_Object window
);
3405 static Lisp_Object
select_frame_norecord (Lisp_Object frame
);
3408 run_window_configuration_change_hook (struct frame
*f
)
3410 int count
= SPECPDL_INDEX ();
3411 Lisp_Object frame
, global_wcch
3412 = Fdefault_value (Qwindow_configuration_change_hook
);
3413 XSETFRAME (frame
, f
);
3415 if (NILP (Vrun_hooks
))
3418 if (SELECTED_FRAME () != f
)
3420 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3421 Fselect_frame (frame
, Qt
);
3424 /* Use the right buffer. Matters when running the local hooks. */
3425 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3427 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3428 Fset_buffer (Fwindow_buffer (Qnil
));
3431 /* Look for buffer-local values. */
3433 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3434 for (; CONSP (windows
); windows
= XCDR (windows
))
3436 Lisp_Object window
= XCAR (windows
);
3437 Lisp_Object buffer
= Fwindow_buffer (window
);
3438 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3441 int count
= SPECPDL_INDEX ();
3442 record_unwind_protect (select_window_norecord
, Fselected_window ());
3443 select_window_norecord (window
);
3444 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3446 unbind_to (count
, Qnil
);
3451 run_funs (global_wcch
);
3452 unbind_to (count
, Qnil
);
3455 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3456 means it's allowed to run hooks. See make_frame for a case where
3457 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3458 margins, fringes, and scroll-bar settings of the window are not
3459 reset from the buffer's local settings. */
3462 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3464 struct window
*w
= XWINDOW (window
);
3465 struct buffer
*b
= XBUFFER (buffer
);
3466 int count
= SPECPDL_INDEX ();
3467 int samebuf
= EQ (buffer
, w
->buffer
);
3471 if (EQ (window
, selected_window
))
3472 b
->last_selected_window
= window
;
3474 /* Let redisplay errors through. */
3475 b
->display_error_modiff
= 0;
3477 /* Update time stamps of buffer display. */
3478 if (INTEGERP (b
->display_count
))
3479 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3480 b
->display_time
= Fcurrent_time ();
3482 XSETFASTINT (w
->window_end_pos
, 0);
3483 XSETFASTINT (w
->window_end_vpos
, 0);
3484 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3485 w
->window_end_valid
= Qnil
;
3486 if (!(keep_margins_p
&& samebuf
))
3487 { /* If we're not actually changing the buffer, don't reset hscroll and
3488 vscroll. This case happens for example when called from
3489 change_frame_size_1, where we use a dummy call to
3490 Fset_window_buffer on the frame's selected window (and no other)
3491 just in order to run window-configuration-change-hook.
3492 Resetting hscroll and vscroll here is problematic for things like
3493 image-mode and doc-view-mode since it resets the image's position
3494 whenever we resize the frame. */
3495 w
->hscroll
= w
->min_hscroll
= make_number (0);
3497 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3498 set_marker_restricted (w
->start
,
3499 make_number (b
->last_window_start
),
3501 w
->start_at_line_beg
= Qnil
;
3502 w
->force_start
= Qnil
;
3503 XSETFASTINT (w
->last_modified
, 0);
3504 XSETFASTINT (w
->last_overlay_modified
, 0);
3506 /* Maybe we could move this into the `if' but it's not obviously safe and
3507 I doubt it's worth the trouble. */
3508 windows_or_buffers_changed
++;
3510 /* We must select BUFFER for running the window-scroll-functions. */
3511 /* We can't check ! NILP (Vwindow_scroll_functions) here
3512 because that might itself be a local variable. */
3513 if (window_initialized
)
3515 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3516 Fset_buffer (buffer
);
3519 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3521 if (!keep_margins_p
)
3523 /* Set left and right marginal area width etc. from buffer. */
3525 /* This may call adjust_window_margins three times, so
3526 temporarily disable window margins. */
3527 Lisp_Object save_left
= w
->left_margin_cols
;
3528 Lisp_Object save_right
= w
->right_margin_cols
;
3530 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3532 Fset_window_fringes (window
,
3533 b
->left_fringe_width
, b
->right_fringe_width
,
3534 b
->fringes_outside_margins
);
3536 Fset_window_scroll_bars (window
,
3537 b
->scroll_bar_width
,
3538 b
->vertical_scroll_bar_type
, Qnil
);
3540 w
->left_margin_cols
= save_left
;
3541 w
->right_margin_cols
= save_right
;
3543 Fset_window_margins (window
,
3544 b
->left_margin_cols
, b
->right_margin_cols
);
3549 if (! NILP (Vwindow_scroll_functions
))
3550 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3551 Fmarker_position (w
->start
));
3552 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3555 unbind_to (count
, Qnil
);
3559 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3560 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3561 WINDOW defaults to the selected window. BUFFER-OR-NAME must be a buffer
3562 or the name of an existing buffer. Optional third argument KEEP-MARGINS
3563 non-nil means that WINDOW's current display margins, fringe widths, and
3564 scroll bar settings are preserved; the default is to reset these from
3565 the local settings for BUFFER-OR-NAME or the frame defaults. Return nil.
3567 This function throws an error when WINDOW is strongly dedicated to its
3568 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3569 already display BUFFER-OR-NAME.
3571 This function runs `window-scroll-functions' before running
3572 `window-configuration-change-hook'. */)
3573 (window
, buffer_or_name
, keep_margins
)
3574 register Lisp_Object window
, buffer_or_name
, keep_margins
;
3576 register Lisp_Object tem
, buffer
;
3577 register struct window
*w
= decode_window (window
);
3579 XSETWINDOW (window
, w
);
3580 buffer
= Fget_buffer (buffer_or_name
);
3581 CHECK_BUFFER (buffer
);
3582 if (NILP (XBUFFER (buffer
)->name
))
3583 error ("Attempt to display deleted buffer");
3587 error ("Window is deleted");
3588 else if (!EQ (tem
, Qt
))
3589 /* w->buffer is t when the window is first being set up. */
3591 if (!EQ (tem
, buffer
))
3592 if (EQ (w
->dedicated
, Qt
))
3593 error ("Window is dedicated to `%s'", SDATA (XBUFFER (tem
)->name
));
3595 w
->dedicated
= Qnil
;
3600 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3604 /* Note that selected_window can be nil when this is called from
3605 Fset_window_configuration. */
3607 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3608 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3609 If WINDOW is not already selected, make WINDOW's buffer current
3610 and make WINDOW the frame's selected window. Return WINDOW.
3611 Optional second arg NORECORD non-nil means do not put this buffer
3612 at the front of the list of recently selected ones and do not
3613 make this window the most recently selected one.
3615 Note that the main editor command loop selects the buffer of the
3616 selected window before each command. */)
3618 register Lisp_Object window
, norecord
;
3620 register struct window
*w
;
3621 register struct window
*ow
;
3624 CHECK_LIVE_WINDOW (window
);
3626 w
= XWINDOW (window
);
3627 w
->frozen_window_start_p
= 0;
3629 if (NILP (norecord
))
3631 ++window_select_count
;
3632 XSETFASTINT (w
->use_time
, window_select_count
);
3633 record_buffer (w
->buffer
);
3636 if (EQ (window
, selected_window
))
3639 sf
= SELECTED_FRAME ();
3640 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3642 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3643 /* Use this rather than Fhandle_switch_frame
3644 so that FRAME_FOCUS_FRAME is moved appropriately as we
3645 move around in the state where a minibuffer in a separate
3647 Fselect_frame (WINDOW_FRAME (w
), norecord
);
3648 /* Fselect_frame called us back so we've done all the work already. */
3649 eassert (EQ (window
, selected_window
));
3653 sf
->selected_window
= window
;
3655 /* Store the current buffer's actual point into the
3656 old selected window. It belongs to that window,
3657 and when the window is not selected, must be in the window. */
3658 if (!NILP (selected_window
))
3660 ow
= XWINDOW (selected_window
);
3661 if (! NILP (ow
->buffer
))
3662 set_marker_both (ow
->pointm
, ow
->buffer
,
3663 BUF_PT (XBUFFER (ow
->buffer
)),
3664 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3667 selected_window
= window
;
3669 Fset_buffer (w
->buffer
);
3671 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3673 /* Go to the point recorded in the window.
3674 This is important when the buffer is in more
3675 than one window. It also matters when
3676 redisplay_window has altered point after scrolling,
3677 because it makes the change only in the window. */
3679 register int new_point
= marker_position (w
->pointm
);
3680 if (new_point
< BEGV
)
3682 else if (new_point
> ZV
)
3688 windows_or_buffers_changed
++;
3693 select_window_norecord (Lisp_Object window
)
3695 return WINDOW_LIVE_P (window
)
3696 ? Fselect_window (window
, Qt
) : selected_window
;
3700 select_frame_norecord (Lisp_Object frame
)
3702 return FRAME_LIVE_P (XFRAME (frame
))
3703 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3707 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3709 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3712 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3714 doc
: /* Force all windows to be updated on next redisplay.
3715 If optional arg OBJECT is a window, force redisplay of that window only.
3716 If OBJECT is a buffer or buffer name, force redisplay of all windows
3717 displaying that buffer. */)
3723 windows_or_buffers_changed
++;
3724 update_mode_lines
++;
3728 if (WINDOWP (object
))
3730 struct window
*w
= XWINDOW (object
);
3731 mark_window_display_accurate (object
, 0);
3732 w
->update_mode_line
= Qt
;
3733 if (BUFFERP (w
->buffer
))
3734 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3735 ++update_mode_lines
;
3739 if (STRINGP (object
))
3740 object
= Fget_buffer (object
);
3741 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3743 /* Walk all windows looking for buffer, and force update
3744 of each of those windows. */
3746 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3747 return NILP (object
) ? Qnil
: Qt
;
3750 /* If nothing suitable was found, just return.
3751 We could signal an error, but this feature will typically be used
3752 asynchronously in timers or process sentinels, so we don't. */
3758 temp_output_buffer_show (register Lisp_Object buf
)
3760 register struct buffer
*old
= current_buffer
;
3761 register Lisp_Object window
;
3762 register struct window
*w
;
3764 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3767 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3771 #if 0 /* rms: there should be no reason for this. */
3772 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3774 set_buffer_internal (old
);
3776 if (!NILP (Vtemp_buffer_show_function
))
3777 call1 (Vtemp_buffer_show_function
, buf
);
3780 window
= display_buffer (buf
, Qnil
, Qnil
);
3782 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3783 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3784 Vminibuf_scroll_window
= window
;
3785 w
= XWINDOW (window
);
3786 XSETFASTINT (w
->hscroll
, 0);
3787 XSETFASTINT (w
->min_hscroll
, 0);
3788 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3789 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3791 /* Run temp-buffer-show-hook, with the chosen window selected
3792 and its buffer current. */
3794 if (!NILP (Vrun_hooks
)
3795 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3796 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3798 int count
= SPECPDL_INDEX ();
3799 Lisp_Object prev_window
, prev_buffer
;
3800 prev_window
= selected_window
;
3801 XSETBUFFER (prev_buffer
, old
);
3803 /* Select the window that was chosen, for running the hook.
3804 Note: Both Fselect_window and select_window_norecord may
3805 set-buffer to the buffer displayed in the window,
3806 so we need to save the current buffer. --stef */
3807 record_unwind_protect (Fset_buffer
, prev_buffer
);
3808 record_unwind_protect (select_window_norecord
, prev_window
);
3809 Fselect_window (window
, Qt
);
3810 Fset_buffer (w
->buffer
);
3811 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3812 unbind_to (count
, Qnil
);
3818 make_dummy_parent (Lisp_Object window
)
3821 register struct window
*o
, *p
;
3824 o
= XWINDOW (window
);
3825 p
= allocate_window ();
3826 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3827 ((struct Lisp_Vector
*) p
)->contents
[i
]
3828 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3829 XSETWINDOW (new, p
);
3832 XSETFASTINT (p
->sequence_number
, sequence_number
);
3834 /* Put new into window structure in place of window */
3835 replace_window (window
, new);
3848 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3849 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3850 WINDOW defaults to selected one and SIZE to half its size.
3851 If optional third arg HORIZONTAL is non-nil, split side by side and put
3852 SIZE columns in the first of the pair. In that case, SIZE includes that
3853 window's scroll bar, or the divider column to its right.
3854 Interactively, all arguments are nil.
3855 Returns the newly created window (which is the lower or rightmost one).
3856 The upper or leftmost window is the original one, and remains selected
3857 if it was selected before.
3859 See Info node `(elisp)Splitting Windows' for more details and examples. */)
3860 (window
, size
, horizontal
)
3861 Lisp_Object window
, size
, horizontal
;
3863 register Lisp_Object
new;
3864 register struct window
*o
, *p
;
3866 register int size_int
;
3869 window
= selected_window
;
3871 CHECK_LIVE_WINDOW (window
);
3873 o
= XWINDOW (window
);
3874 fo
= XFRAME (WINDOW_FRAME (o
));
3878 if (!NILP (horizontal
))
3879 /* Calculate the size of the left-hand window, by dividing
3880 the usable space in columns by two.
3881 We round up, since the left-hand window may include
3882 a dividing line, while the right-hand may not. */
3883 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3885 size_int
= XFASTINT (o
->total_lines
) >> 1;
3889 CHECK_NUMBER (size
);
3890 size_int
= XINT (size
);
3893 if (MINI_WINDOW_P (o
))
3894 error ("Attempt to split minibuffer window");
3895 else if (window_fixed_size_p (o
, !NILP (horizontal
), 0))
3896 error ("Attempt to split fixed-size window");
3898 if (NILP (horizontal
))
3900 int window_safe_height
= window_min_size_2 (o
, 0, 0);
3902 if (size_int
< window_safe_height
)
3903 error ("Window height %d too small (after splitting)", size_int
);
3904 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
3905 error ("Window height %d too small (after splitting)",
3906 XFASTINT (o
->total_lines
) - size_int
);
3907 if (NILP (o
->parent
)
3908 || NILP (XWINDOW (o
->parent
)->vchild
))
3910 make_dummy_parent (window
);
3912 XWINDOW (new)->vchild
= window
;
3917 int window_safe_width
= window_min_size_2 (o
, 1, 0);
3919 if (size_int
< window_safe_width
)
3920 error ("Window width %d too small (after splitting)", size_int
);
3921 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
3922 error ("Window width %d too small (after splitting)",
3923 XFASTINT (o
->total_cols
) - size_int
);
3924 if (NILP (o
->parent
)
3925 || NILP (XWINDOW (o
->parent
)->hchild
))
3927 make_dummy_parent (window
);
3929 XWINDOW (new)->hchild
= window
;
3933 /* Now we know that window's parent is a vertical combination
3934 if we are dividing vertically, or a horizontal combination
3935 if we are making side-by-side windows */
3937 windows_or_buffers_changed
++;
3938 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3939 new = make_window ();
3942 p
->frame
= o
->frame
;
3944 if (!NILP (p
->next
))
3945 XWINDOW (p
->next
)->prev
= new;
3948 p
->parent
= o
->parent
;
3950 p
->window_end_valid
= Qnil
;
3951 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3953 /* Duplicate special geometry settings. */
3955 p
->left_margin_cols
= o
->left_margin_cols
;
3956 p
->right_margin_cols
= o
->right_margin_cols
;
3957 p
->left_fringe_width
= o
->left_fringe_width
;
3958 p
->right_fringe_width
= o
->right_fringe_width
;
3959 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3960 p
->scroll_bar_width
= o
->scroll_bar_width
;
3961 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3963 /* Apportion the available frame space among the two new windows */
3965 if (!NILP (horizontal
))
3967 p
->total_lines
= o
->total_lines
;
3968 p
->top_line
= o
->top_line
;
3969 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3970 XSETFASTINT (o
->total_cols
, size_int
);
3971 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3972 adjust_window_margins (p
);
3973 adjust_window_margins (o
);
3977 p
->left_col
= o
->left_col
;
3978 p
->total_cols
= o
->total_cols
;
3979 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3980 XSETFASTINT (o
->total_lines
, size_int
);
3981 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3984 /* Adjust glyph matrices. */
3987 Fset_window_buffer (new, o
->buffer
, Qt
);
3991 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3992 doc
: /* Make selected window SIZE lines taller.
3993 Interactively, if no argument is given, make the selected window one
3994 line taller. If optional argument HORIZONTAL is non-nil, make selected
3995 window wider by SIZE columns. If SIZE is negative, shrink the window by
3996 -SIZE lines or columns. Return nil.
3998 This function can delete windows if they get too small. The size of
3999 fixed size windows is not altered by this function. */)
4001 Lisp_Object size
, horizontal
;
4003 CHECK_NUMBER (size
);
4004 enlarge_window (selected_window
, XINT (size
), !NILP (horizontal
));
4006 run_window_configuration_change_hook (SELECTED_FRAME ());
4011 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
4012 doc
: /* Make selected window SIZE lines smaller.
4013 Interactively, if no argument is given, make the selected window one
4014 line smaller. If optional argument HORIZONTAL is non-nil, make the
4015 window narrower by SIZE columns. If SIZE is negative, enlarge selected
4016 window by -SIZE lines or columns. Return nil.
4018 This function can delete windows if they get too small. The size of
4019 fixed size windows is not altered by this function. */)
4021 Lisp_Object size
, horizontal
;
4023 CHECK_NUMBER (size
);
4024 enlarge_window (selected_window
, -XINT (size
), !NILP (horizontal
));
4026 run_window_configuration_change_hook (SELECTED_FRAME ());
4032 window_height (Lisp_Object window
)
4034 register struct window
*p
= XWINDOW (window
);
4035 return WINDOW_TOTAL_LINES (p
);
4039 window_width (Lisp_Object window
)
4041 register struct window
*p
= XWINDOW (window
);
4042 return WINDOW_TOTAL_COLS (p
);
4047 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4049 #define CURSIZE(w) \
4050 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4053 /* Enlarge WINDOW by DELTA. HORIZ_FLAG nonzero means enlarge it
4054 horizontally; zero means do it vertically.
4056 Siblings of the selected window are resized to fulfill the size
4057 request. If they become too small in the process, they may be
4061 enlarge_window (Lisp_Object window
, int delta
, int horiz_flag
)
4063 Lisp_Object parent
, next
, prev
;
4067 int (*sizefun
) (Lisp_Object
)
4068 = horiz_flag
? window_width
: window_height
;
4069 void (*setsizefun
) (Lisp_Object
, int, int)
4070 = (horiz_flag
? set_window_width
: set_window_height
);
4072 /* Give up if this window cannot be resized. */
4073 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4074 error ("Window is not resizable");
4076 /* Find the parent of the selected window. */
4079 p
= XWINDOW (window
);
4085 error ("No other window to side of this one");
4090 ? !NILP (XWINDOW (parent
)->hchild
)
4091 : !NILP (XWINDOW (parent
)->vchild
))
4097 sizep
= &CURSIZE (window
);
4100 register int maxdelta
;
4102 /* Compute the maximum size increment this window can have. */
4104 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4105 /* This is a main window followed by a minibuffer. */
4106 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4107 - window_min_size (XWINDOW (p
->next
),
4108 horiz_flag
, 0, 0, 0))
4109 /* This is a minibuffer following a main window. */
4110 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4111 - window_min_size (XWINDOW (p
->prev
),
4112 horiz_flag
, 0, 0, 0))
4113 /* This is a frame with only one window, a minibuffer-only
4114 or a minibufferless frame. */
4117 if (delta
> maxdelta
)
4118 /* This case traps trying to make the minibuffer
4119 the full frame, or make the only window aside from the
4120 minibuffer the full frame. */
4124 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
),
4125 horiz_flag
, 0, 0, 0))
4127 delete_window (window
);
4134 /* Find the total we can get from other siblings without deleting them. */
4136 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4137 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4138 horiz_flag
, 0, 0, 0);
4139 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4140 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4141 horiz_flag
, 0, 0, 0);
4143 /* If we can get it all from them without deleting them, do so. */
4144 if (delta
<= maximum
)
4146 Lisp_Object first_unaffected
;
4147 Lisp_Object first_affected
;
4152 first_affected
= window
;
4153 /* Look at one sibling at a time,
4154 moving away from this window in both directions alternately,
4155 and take as much as we can get without deleting that sibling. */
4157 && (!NILP (next
) || !NILP (prev
)))
4161 int this_one
= ((*sizefun
) (next
)
4162 - window_min_size (XWINDOW (next
), horiz_flag
,
4166 if (this_one
> delta
)
4169 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4170 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4175 next
= XWINDOW (next
)->next
;
4183 int this_one
= ((*sizefun
) (prev
)
4184 - window_min_size (XWINDOW (prev
), horiz_flag
,
4188 if (this_one
> delta
)
4191 first_affected
= prev
;
4193 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4194 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4199 prev
= XWINDOW (prev
)->prev
;
4203 xassert (delta
== 0);
4205 /* Now recalculate the edge positions of all the windows affected,
4206 based on the new sizes. */
4207 first_unaffected
= next
;
4208 prev
= first_affected
;
4209 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4210 prev
= next
, next
= XWINDOW (next
)->next
)
4212 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4213 /* This does not change size of NEXT,
4214 but it propagates the new top edge to its children */
4215 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4220 register int delta1
;
4221 register int opht
= (*sizefun
) (parent
);
4223 if (opht
<= XINT (*sizep
) + delta
)
4225 /* If trying to grow this window to or beyond size of the parent,
4226 just delete all the sibling windows. */
4227 Lisp_Object start
, tem
, next
;
4229 start
= XWINDOW (parent
)->vchild
;
4231 start
= XWINDOW (parent
)->hchild
;
4233 /* Delete any siblings that come after WINDOW. */
4234 tem
= XWINDOW (window
)->next
;
4235 while (! NILP (tem
))
4237 next
= XWINDOW (tem
)->next
;
4238 delete_window (tem
);
4242 /* Delete any siblings that come after WINDOW.
4243 Note that if START is not WINDOW, then WINDOW still
4244 has siblings, so WINDOW has not yet replaced its parent. */
4246 while (! EQ (tem
, window
))
4248 next
= XWINDOW (tem
)->next
;
4249 delete_window (tem
);
4255 /* Otherwise, make delta1 just right so that if we add
4256 delta1 lines to this window and to the parent, and then
4257 shrink the parent back to its original size, the new
4258 proportional size of this window will increase by delta.
4260 The function size_window will compute the new height h'
4261 of the window from delta1 as:
4264 x = delta1 - delta1/n * n for the 1st resizable child
4267 where n is the number of children that can be resized.
4268 We can ignore x by choosing a delta1 that is a multiple of
4269 n. We want the height of this window to come out as
4279 The number of children n equals the number of resizable
4280 children of this window + 1 because we know window itself
4281 is resizable (otherwise we would have signaled an error).
4283 This reasoning is not correct when other windows become too
4284 small and shrink_windows refuses to delete them. Below we
4285 use resize_proportionally to work around this problem. */
4287 struct window
*w
= XWINDOW (window
);
4291 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4292 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4294 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4295 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4300 /* Add delta1 lines or columns to this window, and to the parent,
4301 keeping things consistent while not affecting siblings. */
4302 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4303 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4305 /* Squeeze out delta1 lines or columns from our parent,
4306 shrinking this window and siblings proportionately. This
4307 brings parent back to correct size. Delta1 was calculated
4308 so this makes this window the desired size, taking it all
4309 out of the siblings.
4311 Temporarily set resize_proportionally to Qt to assure that,
4312 if necessary, shrink_windows deletes smaller windows rather
4313 than shrink this window. */
4314 w
->resize_proportionally
= Qt
;
4315 (*setsizefun
) (parent
, opht
, 0);
4316 w
->resize_proportionally
= Qnil
;
4320 XSETFASTINT (p
->last_modified
, 0);
4321 XSETFASTINT (p
->last_overlay_modified
, 0);
4323 /* Adjust glyph matrices. */
4324 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4328 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4329 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4330 zero means adjust the height, moving the bottom edge.
4332 Following siblings of the selected window are resized to fulfill
4333 the size request. If they become too small in the process, they
4334 are not deleted; instead, we signal an error. */
4337 adjust_window_trailing_edge (Lisp_Object window
, int delta
, int horiz_flag
)
4339 Lisp_Object parent
, child
;
4341 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4342 int delcount
= window_deletion_count
;
4344 CHECK_WINDOW (window
);
4346 /* Give up if this window cannot be resized. */
4347 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4348 error ("Window is not resizable");
4352 Lisp_Object first_parallel
= Qnil
;
4356 /* This happens if WINDOW on the previous iteration was
4357 at top level of the window tree. */
4358 Fset_window_configuration (old_config
);
4359 error ("Specified window edge is fixed");
4362 p
= XWINDOW (window
);
4365 /* See if this level has windows in parallel in the specified
4366 direction. If so, set FIRST_PARALLEL to the first one. */
4369 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4370 first_parallel
= XWINDOW (parent
)->vchild
;
4371 else if (NILP (parent
) && !NILP (p
->next
))
4373 /* Handle the vertical chain of main window and minibuffer
4374 which has no parent. */
4375 first_parallel
= window
;
4376 while (! NILP (XWINDOW (first_parallel
)->prev
))
4377 first_parallel
= XWINDOW (first_parallel
)->prev
;
4382 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4383 first_parallel
= XWINDOW (parent
)->hchild
;
4386 /* If this level's succession is in the desired dimension,
4387 and this window is the last one, and there is no higher level,
4388 its trailing edge is fixed. */
4389 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4392 Fset_window_configuration (old_config
);
4393 error ("Specified window edge is fixed");
4396 /* Don't make this window too small. */
4397 if (XINT (CURSIZE (window
)) + delta
4398 < window_min_size_2 (XWINDOW (window
), horiz_flag
, 0))
4400 Fset_window_configuration (old_config
);
4401 error ("Cannot adjust window size as specified");
4404 /* Clear out some redisplay caches. */
4405 XSETFASTINT (p
->last_modified
, 0);
4406 XSETFASTINT (p
->last_overlay_modified
, 0);
4408 /* Adjust this window's edge. */
4409 XSETINT (CURSIZE (window
),
4410 XINT (CURSIZE (window
)) + delta
);
4412 /* If this window has following siblings in the desired dimension,
4413 make them smaller, and exit the loop.
4415 (If we reach the top of the tree and can never do this,
4416 we will fail and report an error, above.) */
4417 if (NILP (first_parallel
))
4419 if (!NILP (p
->next
))
4421 /* This may happen for the minibuffer. In that case
4422 the window_deletion_count check below does not work. */
4423 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4425 Fset_window_configuration (old_config
);
4426 error ("Cannot adjust window size as specified");
4429 XSETINT (CURBEG (p
->next
),
4430 XINT (CURBEG (p
->next
)) + delta
);
4431 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4432 horiz_flag
, 0, 1, 0);
4437 /* Here we have a chain of parallel siblings, in the other dimension.
4438 Change the size of the other siblings. */
4439 for (child
= first_parallel
;
4441 child
= XWINDOW (child
)->next
)
4442 if (! EQ (child
, window
))
4443 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4444 horiz_flag
, 0, 0, 1);
4449 /* If we made a window so small it got deleted,
4450 we failed. Report failure. */
4451 if (delcount
!= window_deletion_count
)
4453 Fset_window_configuration (old_config
);
4454 error ("Cannot adjust window size as specified");
4457 /* Adjust glyph matrices. */
4458 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4464 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4465 Sadjust_window_trailing_edge
, 3, 3, 0,
4466 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4467 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4468 Otherwise, adjust the height, moving the bottom edge.
4470 Following siblings of the selected window are resized to fulfill
4471 the size request. If they become too small in the process, they
4472 are not deleted; instead, we signal an error. */)
4473 (window
, delta
, horizontal
)
4474 Lisp_Object window
, delta
, horizontal
;
4476 CHECK_NUMBER (delta
);
4478 window
= selected_window
;
4479 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4481 run_window_configuration_change_hook
4482 (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4489 /***********************************************************************
4490 Resizing Mini-Windows
4491 ***********************************************************************/
4493 static void shrink_window_lowest_first (struct window
*, int);
4495 enum save_restore_action
4502 static int save_restore_orig_size (struct window
*,
4503 enum save_restore_action
);
4505 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4506 from lowest windows first. */
4509 shrink_window_lowest_first (struct window
*w
, int height
)
4515 xassert (!MINI_WINDOW_P (w
));
4517 /* Set redisplay hints. */
4518 XSETFASTINT (w
->last_modified
, 0);
4519 XSETFASTINT (w
->last_overlay_modified
, 0);
4520 windows_or_buffers_changed
++;
4521 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4523 old_height
= XFASTINT (w
->total_lines
);
4524 XSETFASTINT (w
->total_lines
, height
);
4526 if (!NILP (w
->hchild
))
4528 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4530 c
= XWINDOW (child
);
4531 c
->top_line
= w
->top_line
;
4532 shrink_window_lowest_first (c
, height
);
4535 else if (!NILP (w
->vchild
))
4537 Lisp_Object last_child
;
4538 int delta
= old_height
- height
;
4543 /* Find the last child. We are taking space from lowest windows
4544 first, so we iterate over children from the last child
4546 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4549 /* Size children down to their safe heights. */
4550 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4554 c
= XWINDOW (child
);
4555 this_one
= XFASTINT (c
->total_lines
) - window_min_size_1 (c
, 0, 1);
4557 if (this_one
> delta
)
4560 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4564 /* Compute new positions. */
4565 last_top
= XINT (w
->top_line
);
4566 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4568 c
= XWINDOW (child
);
4569 c
->top_line
= make_number (last_top
);
4570 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4571 last_top
+= XFASTINT (c
->total_lines
);
4577 /* Save, restore, or check positions and sizes in the window tree
4578 rooted at W. ACTION says what to do.
4580 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4581 orig_total_lines members are valid for all windows in the window
4582 tree. Value is non-zero if they are valid.
4584 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4585 orig_top_line and orig_total_lines for all windows in the tree.
4587 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4588 stored in orig_top_line and orig_total_lines for all windows. */
4591 save_restore_orig_size (struct window
*w
, enum save_restore_action action
)
4597 if (!NILP (w
->hchild
))
4599 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4602 else if (!NILP (w
->vchild
))
4604 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4610 case CHECK_ORIG_SIZES
:
4611 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4615 case SAVE_ORIG_SIZES
:
4616 w
->orig_top_line
= w
->top_line
;
4617 w
->orig_total_lines
= w
->total_lines
;
4618 XSETFASTINT (w
->last_modified
, 0);
4619 XSETFASTINT (w
->last_overlay_modified
, 0);
4622 case RESTORE_ORIG_SIZES
:
4623 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4624 w
->top_line
= w
->orig_top_line
;
4625 w
->total_lines
= w
->orig_total_lines
;
4626 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4627 XSETFASTINT (w
->last_modified
, 0);
4628 XSETFASTINT (w
->last_overlay_modified
, 0);
4635 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4642 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4643 without deleting other windows. */
4646 grow_mini_window (struct window
*w
, int delta
)
4648 struct frame
*f
= XFRAME (w
->frame
);
4649 struct window
*root
;
4651 xassert (MINI_WINDOW_P (w
));
4652 /* Commenting out the following assertion goes against the stated interface
4653 of the function, but it currently does not seem to do anything useful.
4654 See discussion of this issue in the thread for bug#4534.
4655 xassert (delta >= 0); */
4657 /* Compute how much we can enlarge the mini-window without deleting
4659 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4662 int min_height
= window_min_size (root
, 0, 0, 0, 0);
4663 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4664 /* Note that the root window may already be smaller than
4666 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4671 /* Save original window sizes and positions, if not already done. */
4672 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4673 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4675 /* Shrink other windows. */
4676 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4678 /* Grow the mini-window. */
4679 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4680 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4681 XSETFASTINT (w
->last_modified
, 0);
4682 XSETFASTINT (w
->last_overlay_modified
, 0);
4689 /* Shrink mini-window W. If there is recorded info about window sizes
4690 before a call to grow_mini_window, restore recorded window sizes.
4691 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4695 shrink_mini_window (struct window
*w
)
4697 struct frame
*f
= XFRAME (w
->frame
);
4698 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4700 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4702 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4704 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4705 windows_or_buffers_changed
= 1;
4707 else if (XFASTINT (w
->total_lines
) > 1)
4709 /* Distribute the additional lines of the mini-window
4710 among the other windows. */
4712 XSETWINDOW (window
, w
);
4713 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4719 /* Mark window cursors off for all windows in the window tree rooted
4720 at W by setting their phys_cursor_on_p flag to zero. Called from
4721 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4722 the frame are cleared. */
4725 mark_window_cursors_off (struct window
*w
)
4729 if (!NILP (w
->hchild
))
4730 mark_window_cursors_off (XWINDOW (w
->hchild
));
4731 else if (!NILP (w
->vchild
))
4732 mark_window_cursors_off (XWINDOW (w
->vchild
));
4734 w
->phys_cursor_on_p
= 0;
4736 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4741 /* Return number of lines of text (not counting mode lines) in W. */
4744 window_internal_height (struct window
*w
)
4746 int ht
= XFASTINT (w
->total_lines
);
4748 if (!MINI_WINDOW_P (w
))
4750 if (!NILP (w
->parent
)
4751 || !NILP (w
->vchild
)
4752 || !NILP (w
->hchild
)
4755 || WINDOW_WANTS_MODELINE_P (w
))
4758 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4766 /* Return the number of columns in W.
4767 Don't count columns occupied by scroll bars or the vertical bar
4768 separating W from the sibling to its right. */
4771 window_box_text_cols (struct window
*w
)
4773 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4774 int width
= XINT (w
->total_cols
);
4776 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4777 /* Scroll bars occupy a few columns. */
4778 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4779 else if (!FRAME_WINDOW_P (f
)
4780 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4781 /* The column of `|' characters separating side-by-side windows
4782 occupies one column only. */
4785 if (FRAME_WINDOW_P (f
))
4786 /* On window-systems, fringes and display margins cannot be
4787 used for normal text. */
4788 width
-= (WINDOW_FRINGE_COLS (w
)
4789 + WINDOW_LEFT_MARGIN_COLS (w
)
4790 + WINDOW_RIGHT_MARGIN_COLS (w
));
4796 /************************************************************************
4798 ***********************************************************************/
4800 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4801 N screen-fulls, which is defined as the height of the window minus
4802 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4803 instead. Negative values of N mean scroll down. NOERROR non-zero
4804 means don't signal an error if we try to move over BEGV or ZV,
4808 window_scroll (Lisp_Object window
, int n
, int whole
, int noerror
)
4812 /* If we must, use the pixel-based version which is much slower than
4813 the line-based one but can handle varying line heights. */
4814 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4815 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4817 window_scroll_line_based (window
, n
, whole
, noerror
);
4823 /* Implementation of window_scroll that works based on pixel line
4824 heights. See the comment of window_scroll for parameter
4828 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4831 struct window
*w
= XWINDOW (window
);
4832 struct text_pos start
;
4833 int this_scroll_margin
;
4834 /* True if we fiddled the window vscroll field without really scrolling. */
4836 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4838 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4840 /* If PT is not visible in WINDOW, move back one half of
4841 the screen. Allow PT to be partially visible, otherwise
4842 something like (scroll-down 1) with PT in the line before
4843 the partially visible one would recenter. */
4845 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4847 /* Move backward half the height of the window. Performance note:
4848 vmotion used here is about 10% faster, but would give wrong
4849 results for variable height lines. */
4850 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4851 it
.current_y
= it
.last_visible_y
;
4852 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4854 /* The function move_iterator_vertically may move over more than
4855 the specified y-distance. If it->w is small, e.g. a
4856 mini-buffer window, we may end up in front of the window's
4857 display area. This is the case when Start displaying at the
4858 start of the line containing PT in this case. */
4859 if (it
.current_y
<= 0)
4861 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4862 move_it_vertically_backward (&it
, 0);
4866 start
= it
.current
.pos
;
4868 else if (auto_window_vscroll_p
)
4870 if (rtop
|| rbot
) /* partially visible */
4873 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4875 dy
= max ((window_box_height (w
)
4876 - next_screen_context_lines
* dy
),
4882 /* Only vscroll backwards if already vscrolled forwards. */
4883 if (w
->vscroll
< 0 && rtop
> 0)
4885 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4886 Fset_window_vscroll (window
, make_number (px
), Qt
);
4892 /* Do vscroll if already vscrolled or only display line. */
4893 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4895 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4896 Fset_window_vscroll (window
, make_number (px
), Qt
);
4900 /* Maybe modify window start instead of scrolling. */
4901 if (rbot
> 0 || w
->vscroll
< 0)
4905 Fset_window_vscroll (window
, make_number (0), Qt
);
4906 /* If there are other text lines above the current row,
4907 move window start to current row. Else to next row. */
4909 spos
= XINT (Fline_beginning_position (Qnil
));
4911 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4912 set_marker_restricted (w
->start
, make_number (spos
),
4914 w
->start_at_line_beg
= Qt
;
4915 w
->update_mode_line
= Qt
;
4916 XSETFASTINT (w
->last_modified
, 0);
4917 XSETFASTINT (w
->last_overlay_modified
, 0);
4918 /* Set force_start so that redisplay_window will run the
4919 window-scroll-functions. */
4920 w
->force_start
= Qt
;
4925 /* Cancel previous vscroll. */
4926 Fset_window_vscroll (window
, make_number (0), Qt
);
4929 /* If scroll_preserve_screen_position is non-nil, we try to set
4930 point in the same window line as it is now, so get that line. */
4931 if (!NILP (Vscroll_preserve_screen_position
))
4933 /* We preserve the goal pixel coordinate across consecutive
4934 calls to scroll-up, scroll-down and other commands that
4935 have the `scroll-command' property. This avoids the
4936 possibility of point becoming "stuck" on a tall line when
4937 scrolling by one line. */
4938 if (window_scroll_pixel_based_preserve_y
< 0
4939 || !SYMBOLP (current_kboard
->Vlast_command
)
4940 || NILP (Fget (current_kboard
->Vlast_command
, Qscroll_command
)))
4942 start_display (&it
, w
, start
);
4943 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4944 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4945 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4949 window_scroll_pixel_based_preserve_y
4950 = window_scroll_pixel_based_preserve_x
= -1;
4952 /* Move iterator it from start the specified distance forward or
4953 backward. The result is the new window start. */
4954 start_display (&it
, w
, start
);
4957 int start_pos
= IT_CHARPOS (it
);
4958 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4959 dy
= max ((window_box_height (w
)
4960 - next_screen_context_lines
* dy
),
4963 /* Note that move_it_vertically always moves the iterator to the
4964 start of a line. So, if the last line doesn't have a newline,
4965 we would end up at the start of the line ending at ZV. */
4968 move_it_vertically_backward (&it
, -dy
);
4969 /* Ensure we actually do move, e.g. in case we are currently
4970 looking at an image that is taller that the window height. */
4971 while (start_pos
== IT_CHARPOS (it
)
4972 && start_pos
> BEGV
)
4973 move_it_by_lines (&it
, -1, 1);
4977 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4978 MOVE_TO_POS
| MOVE_TO_Y
);
4979 /* Ensure we actually do move, e.g. in case we are currently
4980 looking at an image that is taller that the window height. */
4981 while (start_pos
== IT_CHARPOS (it
)
4983 move_it_by_lines (&it
, 1, 1);
4987 move_it_by_lines (&it
, n
, 1);
4989 /* We failed if we find ZV is already on the screen (scrolling up,
4990 means there's nothing past the end), or if we can't start any
4991 earlier (scrolling down, means there's nothing past the top). */
4992 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4993 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4995 if (IT_CHARPOS (it
) == ZV
)
4997 if (it
.current_y
< it
.last_visible_y
4998 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4999 > it
.last_visible_y
))
5001 /* The last line was only partially visible, make it fully
5003 w
->vscroll
= (it
.last_visible_y
5004 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
5005 adjust_glyphs (it
.f
);
5009 else if (n
< 0) /* could happen with empty buffers */
5010 xsignal0 (Qbeginning_of_buffer
);
5012 xsignal0 (Qend_of_buffer
);
5016 if (w
->vscroll
!= 0)
5017 /* The first line was only partially visible, make it fully
5023 xsignal0 (Qbeginning_of_buffer
);
5026 /* If control gets here, then we vscrolled. */
5028 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5030 /* Don't try to change the window start below. */
5036 int pos
= IT_CHARPOS (it
);
5039 /* If in the middle of a multi-glyph character move forward to
5040 the next character. */
5041 if (in_display_vector_p (&it
))
5044 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5047 /* Set the window start, and set up the window for redisplay. */
5048 set_marker_restricted (w
->start
, make_number (pos
),
5050 bytepos
= XMARKER (w
->start
)->bytepos
;
5051 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5053 w
->update_mode_line
= Qt
;
5054 XSETFASTINT (w
->last_modified
, 0);
5055 XSETFASTINT (w
->last_overlay_modified
, 0);
5056 /* Set force_start so that redisplay_window will run the
5057 window-scroll-functions. */
5058 w
->force_start
= Qt
;
5061 /* The rest of this function uses current_y in a nonstandard way,
5062 not including the height of the header line if any. */
5063 it
.current_y
= it
.vpos
= 0;
5065 /* Move PT out of scroll margins.
5066 This code wants current_y to be zero at the window start position
5067 even if there is a header line. */
5068 this_scroll_margin
= max (0, scroll_margin
);
5069 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5070 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5074 /* We moved the window start towards ZV, so PT may be now
5075 in the scroll margin at the top. */
5076 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5077 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5078 && (NILP (Vscroll_preserve_screen_position
)
5079 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5080 /* We found PT at a legitimate height. Leave it alone. */
5082 else if (window_scroll_pixel_based_preserve_y
>= 0)
5084 /* If we have a header line, take account of it.
5085 This is necessary because we set it.current_y to 0, above. */
5086 move_it_to (&it
, -1,
5087 window_scroll_pixel_based_preserve_x
,
5088 window_scroll_pixel_based_preserve_y
5089 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5090 -1, MOVE_TO_Y
| MOVE_TO_X
);
5091 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5095 while (it
.current_y
< this_scroll_margin
)
5097 int prev
= it
.current_y
;
5098 move_it_by_lines (&it
, 1, 1);
5099 if (prev
== it
.current_y
)
5102 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5107 int charpos
, bytepos
;
5110 /* Save our position, for the
5111 window_scroll_pixel_based_preserve_y case. */
5112 charpos
= IT_CHARPOS (it
);
5113 bytepos
= IT_BYTEPOS (it
);
5115 /* We moved the window start towards BEGV, so PT may be now
5116 in the scroll margin at the bottom. */
5117 move_it_to (&it
, PT
, -1,
5118 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5119 - this_scroll_margin
- 1),
5121 MOVE_TO_POS
| MOVE_TO_Y
);
5123 /* Save our position, in case it's correct. */
5124 charpos
= IT_CHARPOS (it
);
5125 bytepos
= IT_BYTEPOS (it
);
5127 /* See if point is on a partially visible line at the end. */
5128 if (it
.what
== IT_EOB
)
5129 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5132 move_it_by_lines (&it
, 1, 1);
5133 partial_p
= it
.current_y
> it
.last_visible_y
;
5136 if (charpos
== PT
&& !partial_p
5137 && (NILP (Vscroll_preserve_screen_position
)
5138 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5139 /* We found PT before we found the display margin, so PT is ok. */
5141 else if (window_scroll_pixel_based_preserve_y
>= 0)
5143 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5144 start_display (&it
, w
, start
);
5145 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5146 here because we called start_display again and did not
5147 alter it.current_y this time. */
5148 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
5149 window_scroll_pixel_based_preserve_y
, -1,
5150 MOVE_TO_Y
| MOVE_TO_X
);
5151 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5156 /* The last line was only partially visible, so back up two
5157 lines to make sure we're on a fully visible line. */
5159 move_it_by_lines (&it
, -2, 0);
5160 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5163 /* No, the position we saved is OK, so use it. */
5164 SET_PT_BOTH (charpos
, bytepos
);
5170 /* Implementation of window_scroll that works based on screen lines.
5171 See the comment of window_scroll for parameter descriptions. */
5174 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
5176 register struct window
*w
= XWINDOW (window
);
5177 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5178 register int pos
, pos_byte
;
5179 register int ht
= window_internal_height (w
);
5180 register Lisp_Object tem
;
5184 Lisp_Object original_pos
= Qnil
;
5186 /* If scrolling screen-fulls, compute the number of lines to
5187 scroll from the window's height. */
5189 n
*= max (1, ht
- next_screen_context_lines
);
5191 startpos
= marker_position (w
->start
);
5193 if (!NILP (Vscroll_preserve_screen_position
))
5195 if (window_scroll_preserve_vpos
<= 0
5196 || !SYMBOLP (current_kboard
->Vlast_command
)
5197 || NILP (Fget (current_kboard
->Vlast_command
, Qscroll_command
)))
5199 struct position posit
5200 = *compute_motion (startpos
, 0, 0, 0,
5202 -1, XINT (w
->hscroll
),
5204 window_scroll_preserve_vpos
= posit
.vpos
;
5205 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
5208 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
5209 make_number (window_scroll_preserve_vpos
));
5212 XSETFASTINT (tem
, PT
);
5213 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5217 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5222 lose
= n
< 0 && PT
== BEGV
;
5223 Fvertical_motion (make_number (n
), window
);
5227 SET_PT_BOTH (opoint
, opoint_byte
);
5234 xsignal0 (Qbeginning_of_buffer
);
5239 int this_scroll_margin
= scroll_margin
;
5241 /* Don't use a scroll margin that is negative or too large. */
5242 if (this_scroll_margin
< 0)
5243 this_scroll_margin
= 0;
5245 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5246 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5248 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5249 w
->start_at_line_beg
= bolp
;
5250 w
->update_mode_line
= Qt
;
5251 XSETFASTINT (w
->last_modified
, 0);
5252 XSETFASTINT (w
->last_overlay_modified
, 0);
5253 /* Set force_start so that redisplay_window will run
5254 the window-scroll-functions. */
5255 w
->force_start
= Qt
;
5257 if (!NILP (Vscroll_preserve_screen_position
)
5258 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5260 SET_PT_BOTH (pos
, pos_byte
);
5261 Fvertical_motion (original_pos
, window
);
5263 /* If we scrolled forward, put point enough lines down
5264 that it is outside the scroll margin. */
5269 if (this_scroll_margin
> 0)
5271 SET_PT_BOTH (pos
, pos_byte
);
5272 Fvertical_motion (make_number (this_scroll_margin
), window
);
5278 if (top_margin
<= opoint
)
5279 SET_PT_BOTH (opoint
, opoint_byte
);
5280 else if (!NILP (Vscroll_preserve_screen_position
))
5282 SET_PT_BOTH (pos
, pos_byte
);
5283 Fvertical_motion (original_pos
, window
);
5286 SET_PT (top_margin
);
5292 /* If we scrolled backward, put point near the end of the window
5293 but not within the scroll margin. */
5294 SET_PT_BOTH (pos
, pos_byte
);
5295 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5296 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5299 bottom_margin
= PT
+ 1;
5301 if (bottom_margin
> opoint
)
5302 SET_PT_BOTH (opoint
, opoint_byte
);
5305 if (!NILP (Vscroll_preserve_screen_position
))
5307 SET_PT_BOTH (pos
, pos_byte
);
5308 Fvertical_motion (original_pos
, window
);
5311 Fvertical_motion (make_number (-1), window
);
5320 xsignal0 (Qend_of_buffer
);
5325 /* Scroll selected_window up or down. If N is nil, scroll a
5326 screen-full which is defined as the height of the window minus
5327 next_screen_context_lines. If N is the symbol `-', scroll.
5328 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5329 up. This is the guts of Fscroll_up and Fscroll_down. */
5332 scroll_command (Lisp_Object n
, int direction
)
5334 int count
= SPECPDL_INDEX ();
5336 xassert (eabs (direction
) == 1);
5338 /* If selected window's buffer isn't current, make it current for
5339 the moment. But don't screw up if window_scroll gets an error. */
5340 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5342 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5343 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5345 /* Make redisplay consider other windows than just selected_window. */
5346 ++windows_or_buffers_changed
;
5350 window_scroll (selected_window
, direction
, 1, 0);
5351 else if (EQ (n
, Qminus
))
5352 window_scroll (selected_window
, -direction
, 1, 0);
5355 n
= Fprefix_numeric_value (n
);
5356 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5359 unbind_to (count
, Qnil
);
5362 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
5363 doc
: /* Scroll text of selected window upward ARG lines.
5364 If ARG is omitted or nil, scroll upward by a near full screen.
5365 A near full screen is `next-screen-context-lines' less than a full screen.
5366 Negative ARG means scroll downward.
5367 If ARG is the atom `-', scroll downward by nearly full screen.
5368 When calling from a program, supply as argument a number, nil, or `-'. */)
5372 scroll_command (arg
, 1);
5376 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
5377 doc
: /* Scroll text of selected window down ARG lines.
5378 If ARG is omitted or nil, scroll down by a near full screen.
5379 A near full screen is `next-screen-context-lines' less than a full screen.
5380 Negative ARG means scroll upward.
5381 If ARG is the atom `-', scroll upward by nearly full screen.
5382 When calling from a program, supply as argument a number, nil, or `-'. */)
5386 scroll_command (arg
, -1);
5390 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5391 doc
: /* Return the other window for \"other window scroll\" commands.
5392 If `other-window-scroll-buffer' is non-nil, a window
5393 showing that buffer is used.
5394 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5395 specifies the window. This takes precedence over
5396 `other-window-scroll-buffer'. */)
5401 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5402 && !NILP (Vminibuf_scroll_window
))
5403 window
= Vminibuf_scroll_window
;
5404 /* If buffer is specified, scroll that buffer. */
5405 else if (!NILP (Vother_window_scroll_buffer
))
5407 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5409 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5413 /* Nothing specified; look for a neighboring window on the same
5415 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5417 if (EQ (window
, selected_window
))
5418 /* That didn't get us anywhere; look for a window on another
5421 window
= Fnext_window (window
, Qnil
, Qt
);
5422 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5423 && ! EQ (window
, selected_window
));
5426 CHECK_LIVE_WINDOW (window
);
5428 if (EQ (window
, selected_window
))
5429 error ("There is no other window");
5434 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5435 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5436 A near full screen is `next-screen-context-lines' less than a full screen.
5437 The next window is the one below the current one; or the one at the top
5438 if the current one is at the bottom. Negative ARG means scroll downward.
5439 If ARG is the atom `-', scroll downward by nearly full screen.
5440 When calling from a program, supply as argument a number, nil, or `-'.
5442 If `other-window-scroll-buffer' is non-nil, scroll the window
5443 showing that buffer, popping the buffer up if necessary.
5444 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5445 specifies the window to scroll. This takes precedence over
5446 `other-window-scroll-buffer'. */)
5452 int count
= SPECPDL_INDEX ();
5454 window
= Fother_window_for_scrolling ();
5455 w
= XWINDOW (window
);
5457 /* Don't screw up if window_scroll gets an error. */
5458 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5459 ++windows_or_buffers_changed
;
5461 Fset_buffer (w
->buffer
);
5462 SET_PT (marker_position (w
->pointm
));
5465 window_scroll (window
, 1, 1, 1);
5466 else if (EQ (arg
, Qminus
))
5467 window_scroll (window
, -1, 1, 1);
5473 window_scroll (window
, XINT (arg
), 0, 1);
5476 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5477 unbind_to (count
, Qnil
);
5482 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5483 doc
: /* Scroll selected window display ARG columns left.
5484 Default for ARG is window width minus 2.
5485 Value is the total amount of leftward horizontal scrolling in
5486 effect after the change.
5487 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5488 lower bound for automatic scrolling, i.e. automatic scrolling
5489 will not scroll a window to a column less than the value returned
5490 by this function. This happens in an interactive call. */)
5492 register Lisp_Object arg
, set_minimum
;
5496 struct window
*w
= XWINDOW (selected_window
);
5499 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5501 arg
= Fprefix_numeric_value (arg
);
5503 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5504 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5506 if (!NILP (set_minimum
))
5507 w
->min_hscroll
= w
->hscroll
;
5512 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5513 doc
: /* Scroll selected window display ARG columns right.
5514 Default for ARG is window width minus 2.
5515 Value is the total amount of leftward horizontal scrolling in
5516 effect after the change.
5517 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5518 lower bound for automatic scrolling, i.e. automatic scrolling
5519 will not scroll a window to a column less than the value returned
5520 by this function. This happens in an interactive call. */)
5522 register Lisp_Object arg
, set_minimum
;
5526 struct window
*w
= XWINDOW (selected_window
);
5529 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5531 arg
= Fprefix_numeric_value (arg
);
5533 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5534 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5536 if (!NILP (set_minimum
))
5537 w
->min_hscroll
= w
->hscroll
;
5542 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5543 doc
: /* Return the window which was selected when entering the minibuffer.
5544 Returns nil, if selected window is not a minibuffer window. */)
5547 if (minibuf_level
> 0
5548 && MINI_WINDOW_P (XWINDOW (selected_window
))
5549 && WINDOW_LIVE_P (minibuf_selected_window
))
5550 return minibuf_selected_window
;
5555 /* Value is the number of lines actually displayed in window W,
5556 as opposed to its height. */
5559 displayed_window_lines (struct window
*w
)
5562 struct text_pos start
;
5563 int height
= window_box_height (w
);
5564 struct buffer
*old_buffer
;
5567 if (XBUFFER (w
->buffer
) != current_buffer
)
5569 old_buffer
= current_buffer
;
5570 set_buffer_internal (XBUFFER (w
->buffer
));
5575 /* In case W->start is out of the accessible range, do something
5576 reasonable. This happens in Info mode when Info-scroll-down
5577 calls (recenter -1) while W->start is 1. */
5578 if (XMARKER (w
->start
)->charpos
< BEGV
)
5579 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5580 else if (XMARKER (w
->start
)->charpos
> ZV
)
5581 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5583 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5585 start_display (&it
, w
, start
);
5586 move_it_vertically (&it
, height
);
5587 bottom_y
= line_bottom_y (&it
);
5589 /* rms: On a non-window display,
5590 the value of it.vpos at the bottom of the screen
5591 seems to be 1 larger than window_box_height (w).
5592 This kludge fixes a bug whereby (move-to-window-line -1)
5593 when ZV is on the last screen line
5594 moves to the previous screen line instead of the last one. */
5595 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5598 /* Add in empty lines at the bottom of the window. */
5599 if (bottom_y
< height
)
5601 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5602 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5606 set_buffer_internal (old_buffer
);
5612 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5613 doc
: /* Center point in selected window and maybe redisplay frame.
5614 With prefix argument ARG, recenter putting point on screen line ARG
5615 relative to the selected window. If ARG is negative, it counts up from the
5616 bottom of the window. (ARG should be less than the height of the window.)
5618 If ARG is omitted or nil, then recenter with point on the middle line of
5619 the selected window; if the variable `recenter-redisplay' is non-nil,
5620 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5621 is set to `grow-only', this resets the tool-bar's height to the minimum
5622 height needed); if `recenter-redisplay' has the special value `tty',
5623 then only tty frame are redrawn.
5625 Just C-u as prefix means put point in the center of the window
5626 and redisplay normally--don't erase and redraw the frame. */)
5628 register Lisp_Object arg
;
5630 struct window
*w
= XWINDOW (selected_window
);
5631 struct buffer
*buf
= XBUFFER (w
->buffer
);
5632 struct buffer
*obuf
= current_buffer
;
5634 int charpos
, bytepos
;
5636 int this_scroll_margin
;
5638 /* If redisplay is suppressed due to an error, try again. */
5639 obuf
->display_error_modiff
= 0;
5643 if (!NILP (Vrecenter_redisplay
)
5644 && (!EQ (Vrecenter_redisplay
, Qtty
)
5645 || !NILP (Ftty_type (selected_frame
))))
5649 /* Invalidate pixel data calculated for all compositions. */
5650 for (i
= 0; i
< n_compositions
; i
++)
5651 composition_table
[i
]->font
= NULL
;
5653 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5655 Fredraw_frame (WINDOW_FRAME (w
));
5656 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5661 else if (CONSP (arg
)) /* Just C-u. */
5665 arg
= Fprefix_numeric_value (arg
);
5670 set_buffer_internal (buf
);
5672 /* Do this after making BUF current
5673 in case scroll_margin is buffer-local. */
5674 this_scroll_margin
= max (0, scroll_margin
);
5675 this_scroll_margin
= min (this_scroll_margin
,
5676 XFASTINT (w
->total_lines
) / 4);
5678 /* Handle centering on a graphical frame specially. Such frames can
5679 have variable-height lines and centering point on the basis of
5680 line counts would lead to strange effects. */
5681 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5688 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5689 start_display (&it
, w
, pt
);
5690 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5691 charpos
= IT_CHARPOS (it
);
5692 bytepos
= IT_BYTEPOS (it
);
5699 int extra_line_spacing
;
5700 int h
= window_box_height (w
);
5702 iarg
= - max (-iarg
, this_scroll_margin
);
5704 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5705 start_display (&it
, w
, pt
);
5707 /* Be sure we have the exact height of the full line containing PT. */
5708 move_it_by_lines (&it
, 0, 1);
5710 /* The amount of pixels we have to move back is the window
5711 height minus what's displayed in the line containing PT,
5712 and the lines below. */
5715 move_it_by_lines (&it
, nlines
, 1);
5717 if (it
.vpos
== nlines
)
5721 /* Last line has no newline */
5722 h
-= line_bottom_y (&it
);
5726 /* Don't reserve space for extra line spacing of last line. */
5727 extra_line_spacing
= it
.max_extra_line_spacing
;
5729 /* If we can't move down NLINES lines because we hit
5730 the end of the buffer, count in some empty lines. */
5731 if (it
.vpos
< nlines
)
5734 extra_line_spacing
= it
.extra_line_spacing
;
5735 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5740 /* Now find the new top line (starting position) of the window. */
5741 start_display (&it
, w
, pt
);
5743 move_it_vertically_backward (&it
, h
);
5745 /* If extra line spacing is present, we may move too far
5746 back. This causes the last line to be only partially
5747 visible (which triggers redisplay to recenter that line
5748 in the middle), so move forward.
5749 But ignore extra line spacing on last line, as it is not
5750 considered to be part of the visible height of the line.
5752 h
+= extra_line_spacing
;
5753 while (-it
.current_y
> h
)
5754 move_it_by_lines (&it
, 1, 1);
5756 charpos
= IT_CHARPOS (it
);
5757 bytepos
= IT_BYTEPOS (it
);
5761 struct position pos
;
5763 iarg
= max (iarg
, this_scroll_margin
);
5765 pos
= *vmotion (PT
, -iarg
, w
);
5766 charpos
= pos
.bufpos
;
5767 bytepos
= pos
.bytepos
;
5772 struct position pos
;
5773 int ht
= window_internal_height (w
);
5780 /* Don't let it get into the margin at either top or bottom. */
5781 iarg
= max (iarg
, this_scroll_margin
);
5782 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5784 pos
= *vmotion (PT
, - iarg
, w
);
5785 charpos
= pos
.bufpos
;
5786 bytepos
= pos
.bytepos
;
5789 /* Set the new window start. */
5790 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5791 w
->window_end_valid
= Qnil
;
5793 w
->optional_new_start
= Qt
;
5795 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5796 w
->start_at_line_beg
= Qt
;
5798 w
->start_at_line_beg
= Qnil
;
5800 set_buffer_internal (obuf
);
5805 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5807 doc
: /* Return the height in lines of the text display area of WINDOW.
5808 WINDOW defaults to the selected window.
5810 The return value does not include the mode line, any header line, nor
5811 any partial-height lines in the text display area. */)
5815 struct window
*w
= decode_window (window
);
5816 int pixel_height
= window_box_height (w
);
5817 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5818 return make_number (line_height
);
5823 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5825 doc
: /* Position point relative to window.
5826 With no argument, position point at center of window.
5827 An argument specifies vertical position within the window;
5828 zero means top of window, negative means relative to bottom of window. */)
5832 struct window
*w
= XWINDOW (selected_window
);
5836 int this_scroll_margin
;
5839 window
= selected_window
;
5840 start
= marker_position (w
->start
);
5841 if (start
< BEGV
|| start
> ZV
)
5843 int height
= window_internal_height (w
);
5844 Fvertical_motion (make_number (- (height
/ 2)), window
);
5845 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5846 w
->start_at_line_beg
= Fbolp ();
5847 w
->force_start
= Qt
;
5850 Fgoto_char (w
->start
);
5852 lines
= displayed_window_lines (w
);
5855 this_scroll_margin
= max (0, scroll_margin
);
5856 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5860 XSETFASTINT (arg
, lines
/ 2);
5863 int iarg
= XINT (Fprefix_numeric_value (arg
));
5866 iarg
= iarg
+ lines
;
5868 #if 0 /* This code would prevent move-to-window-line from moving point
5869 to a place inside the scroll margins (which would cause the
5870 next redisplay to scroll). I wrote this code, but then concluded
5871 it is probably better not to install it. However, it is here
5872 inside #if 0 so as not to lose it. -- rms. */
5874 /* Don't let it get into the margin at either top or bottom. */
5875 iarg
= max (iarg
, this_scroll_margin
);
5876 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5879 arg
= make_number (iarg
);
5882 /* Skip past a partially visible first line. */
5884 XSETINT (arg
, XINT (arg
) + 1);
5886 return Fvertical_motion (arg
, window
);
5891 /***********************************************************************
5892 Window Configuration
5893 ***********************************************************************/
5895 struct save_window_data
5898 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5899 Lisp_Object selected_frame
;
5900 Lisp_Object current_window
;
5901 Lisp_Object current_buffer
;
5902 Lisp_Object minibuf_scroll_window
;
5903 Lisp_Object minibuf_selected_window
;
5904 Lisp_Object root_window
;
5905 Lisp_Object focus_frame
;
5906 /* A vector, each of whose elements is a struct saved_window
5908 Lisp_Object saved_windows
;
5910 /* All fields above are traced by the GC.
5911 From `fame-cols' down, the fields are ignored by the GC. */
5913 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5914 int frame_tool_bar_lines
;
5917 /* This is saved as a Lisp_Vector */
5920 /* these first two must agree with struct Lisp_Vector in lisp.h */
5922 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5925 Lisp_Object buffer
, start
, pointm
, mark
;
5926 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5927 Lisp_Object hscroll
, min_hscroll
;
5928 Lisp_Object parent
, prev
;
5929 Lisp_Object start_at_line_beg
;
5930 Lisp_Object display_table
;
5931 Lisp_Object orig_top_line
, orig_total_lines
;
5932 Lisp_Object left_margin_cols
, right_margin_cols
;
5933 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5934 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5935 Lisp_Object dedicated
, resize_proportionally
;
5938 #define SAVED_WINDOW_N(swv,n) \
5939 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5941 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5942 doc
: /* Return t if OBJECT is a window-configuration object. */)
5946 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5949 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5950 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5954 register struct save_window_data
*data
;
5955 struct Lisp_Vector
*saved_windows
;
5957 CHECK_WINDOW_CONFIGURATION (config
);
5959 data
= (struct save_window_data
*) XVECTOR (config
);
5960 saved_windows
= XVECTOR (data
->saved_windows
);
5961 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5964 DEFUN ("set-window-configuration", Fset_window_configuration
,
5965 Sset_window_configuration
, 1, 1, 0,
5966 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5967 CONFIGURATION must be a value previously returned
5968 by `current-window-configuration' (which see).
5969 If CONFIGURATION was made from a frame that is now deleted,
5970 only frame-independent values can be restored. In this case,
5971 the return value is nil. Otherwise the value is t. */)
5973 Lisp_Object configuration
;
5975 register struct save_window_data
*data
;
5976 struct Lisp_Vector
*saved_windows
;
5977 Lisp_Object new_current_buffer
;
5982 CHECK_WINDOW_CONFIGURATION (configuration
);
5984 data
= (struct save_window_data
*) XVECTOR (configuration
);
5985 saved_windows
= XVECTOR (data
->saved_windows
);
5987 new_current_buffer
= data
->current_buffer
;
5988 if (NILP (XBUFFER (new_current_buffer
)->name
))
5989 new_current_buffer
= Qnil
;
5992 if (XBUFFER (new_current_buffer
) == current_buffer
)
5993 /* The code further down "preserves point" by saving here PT in
5994 old_point and then setting it later back into PT. When the
5995 current-selected-window and the final-selected-window both show
5996 the current buffer, this suffers from the problem that the
5997 current PT is the window-point of the current-selected-window,
5998 while the final PT is the point of the final-selected-window, so
5999 this copy from one PT to the other would end up moving the
6000 window-point of the final-selected-window to the window-point of
6001 the current-selected-window. So we have to be careful which
6002 point of the current-buffer we copy into old_point. */
6003 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6004 && WINDOWP (selected_window
)
6005 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
6006 && !EQ (selected_window
, data
->current_window
))
6007 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6011 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6012 point in new_current_buffer as of the last time this buffer was
6013 used. This can be non-deterministic since it can be changed by
6014 things like jit-lock by mere temporary selection of some random
6015 window that happens to show this buffer.
6016 So if possible we want this arbitrary choice of "which point" to
6017 be the one from the to-be-selected-window so as to prevent this
6018 window's cursor from being copied from another window. */
6019 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6020 /* If current_window = selected_window, its point is in BUF_PT. */
6021 && !EQ (selected_window
, data
->current_window
))
6022 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6024 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
6027 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6030 /* If f is a dead frame, don't bother rebuilding its window tree.
6031 However, there is other stuff we should still try to do below. */
6032 if (FRAME_LIVE_P (f
))
6034 register struct window
*w
;
6035 register struct saved_window
*p
;
6036 struct window
*root_window
;
6037 struct window
**leaf_windows
;
6041 /* If the frame has been resized since this window configuration was
6042 made, we change the frame to the size specified in the
6043 configuration, restore the configuration, and then resize it
6044 back. We keep track of the prevailing height in these variables. */
6045 int previous_frame_lines
= FRAME_LINES (f
);
6046 int previous_frame_cols
= FRAME_COLS (f
);
6047 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6048 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6050 /* The mouse highlighting code could get screwed up
6051 if it runs during this. */
6054 if (data
->frame_lines
!= previous_frame_lines
6055 || data
->frame_cols
!= previous_frame_cols
)
6056 change_frame_size (f
, data
->frame_lines
,
6057 data
->frame_cols
, 0, 0, 0);
6058 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6059 if (data
->frame_menu_bar_lines
6060 != previous_frame_menu_bar_lines
)
6061 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
6063 #ifdef HAVE_WINDOW_SYSTEM
6064 if (data
->frame_tool_bar_lines
6065 != previous_frame_tool_bar_lines
)
6066 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
6071 /* "Swap out" point from the selected window's buffer
6072 into the window itself. (Normally the pointm of the selected
6073 window holds garbage.) We do this now, before
6074 restoring the window contents, and prevent it from
6075 being done later on when we select a new window. */
6076 if (! NILP (XWINDOW (selected_window
)->buffer
))
6078 w
= XWINDOW (selected_window
);
6079 set_marker_both (w
->pointm
,
6081 BUF_PT (XBUFFER (w
->buffer
)),
6082 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6085 windows_or_buffers_changed
++;
6086 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6088 /* Problem: Freeing all matrices and later allocating them again
6089 is a serious redisplay flickering problem. What we would
6090 really like to do is to free only those matrices not reused
6092 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6094 = (struct window
**) alloca (count_windows (root_window
)
6095 * sizeof (struct window
*));
6096 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6099 Mark all windows now on frame as "deleted".
6100 Restoring the new configuration "undeletes" any that are in it.
6102 Save their current buffers in their height fields, since we may
6103 need it later, if a buffer saved in the configuration is now
6105 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6107 for (k
= 0; k
< saved_windows
->size
; k
++)
6109 p
= SAVED_WINDOW_N (saved_windows
, k
);
6110 w
= XWINDOW (p
->window
);
6113 if (!NILP (p
->parent
))
6114 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6115 XFASTINT (p
->parent
))->window
;
6119 if (!NILP (p
->prev
))
6121 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6122 XFASTINT (p
->prev
))->window
;
6123 XWINDOW (w
->prev
)->next
= p
->window
;
6128 if (!NILP (w
->parent
))
6130 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6132 XWINDOW (w
->parent
)->vchild
= p
->window
;
6133 XWINDOW (w
->parent
)->hchild
= Qnil
;
6137 XWINDOW (w
->parent
)->hchild
= p
->window
;
6138 XWINDOW (w
->parent
)->vchild
= Qnil
;
6143 /* If we squirreled away the buffer in the window's height,
6145 if (BUFFERP (w
->total_lines
))
6146 w
->buffer
= w
->total_lines
;
6147 w
->left_col
= p
->left_col
;
6148 w
->top_line
= p
->top_line
;
6149 w
->total_cols
= p
->total_cols
;
6150 w
->total_lines
= p
->total_lines
;
6151 w
->hscroll
= p
->hscroll
;
6152 w
->min_hscroll
= p
->min_hscroll
;
6153 w
->display_table
= p
->display_table
;
6154 w
->orig_top_line
= p
->orig_top_line
;
6155 w
->orig_total_lines
= p
->orig_total_lines
;
6156 w
->left_margin_cols
= p
->left_margin_cols
;
6157 w
->right_margin_cols
= p
->right_margin_cols
;
6158 w
->left_fringe_width
= p
->left_fringe_width
;
6159 w
->right_fringe_width
= p
->right_fringe_width
;
6160 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6161 w
->scroll_bar_width
= p
->scroll_bar_width
;
6162 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6163 w
->dedicated
= p
->dedicated
;
6164 w
->resize_proportionally
= p
->resize_proportionally
;
6165 XSETFASTINT (w
->last_modified
, 0);
6166 XSETFASTINT (w
->last_overlay_modified
, 0);
6168 /* Reinstall the saved buffer and pointers into it. */
6169 if (NILP (p
->buffer
))
6170 w
->buffer
= p
->buffer
;
6173 if (!NILP (XBUFFER (p
->buffer
)->name
))
6174 /* If saved buffer is alive, install it. */
6176 w
->buffer
= p
->buffer
;
6177 w
->start_at_line_beg
= p
->start_at_line_beg
;
6178 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6179 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6180 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6181 p
->mark
, w
->buffer
);
6183 /* As documented in Fcurrent_window_configuration, don't
6184 restore the location of point in the buffer which was
6185 current when the window configuration was recorded. */
6186 if (!EQ (p
->buffer
, new_current_buffer
)
6187 && XBUFFER (p
->buffer
) == current_buffer
)
6188 Fgoto_char (w
->pointm
);
6190 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6191 /* Else unless window has a live buffer, get one. */
6193 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6194 /* This will set the markers to beginning of visible
6196 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6197 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6198 w
->start_at_line_beg
= Qt
;
6201 /* Keeping window's old buffer; make sure the markers
6204 /* Set window markers at start of visible range. */
6205 if (XMARKER (w
->start
)->buffer
== 0)
6206 set_marker_restricted (w
->start
, make_number (0),
6208 if (XMARKER (w
->pointm
)->buffer
== 0)
6209 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6210 BUF_PT (XBUFFER (w
->buffer
)),
6211 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6212 w
->start_at_line_beg
= Qt
;
6217 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6218 /* Prevent "swapping out point" in the old selected window
6219 using the buffer that has been restored into it.
6220 We already swapped out point that from that window's old buffer. */
6221 selected_window
= Qnil
;
6223 /* Arrange *not* to restore point in the buffer that was
6224 current when the window configuration was saved. */
6225 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6226 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6227 make_number (old_point
),
6228 XWINDOW (data
->current_window
)->buffer
);
6230 Fselect_window (data
->current_window
, Qnil
);
6231 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6234 if (NILP (data
->focus_frame
)
6235 || (FRAMEP (data
->focus_frame
)
6236 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6237 Fredirect_frame_focus (frame
, data
->focus_frame
);
6239 #if 0 /* I don't understand why this is needed, and it causes problems
6240 when the frame's old selected window has been deleted. */
6241 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6242 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6246 /* Set the screen height to the value it had before this function. */
6247 if (previous_frame_lines
!= FRAME_LINES (f
)
6248 || previous_frame_cols
!= FRAME_COLS (f
))
6249 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6251 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6252 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6253 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6255 #ifdef HAVE_WINDOW_SYSTEM
6256 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6257 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6262 /* Now, free glyph matrices in windows that were not reused. */
6263 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6265 if (NILP (leaf_windows
[i
]->buffer
))
6267 /* Assert it's not reused as a combination. */
6268 xassert (NILP (leaf_windows
[i
]->hchild
)
6269 && NILP (leaf_windows
[i
]->vchild
));
6270 free_window_matrices (leaf_windows
[i
]);
6272 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6280 /* Fselect_window will have made f the selected frame, so we
6281 reselect the proper frame here. Fhandle_switch_frame will change the
6282 selected window too, but that doesn't make the call to
6283 Fselect_window above totally superfluous; it still sets f's
6285 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6286 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
6288 run_window_configuration_change_hook (f
);
6291 if (!NILP (new_current_buffer
))
6292 Fset_buffer (new_current_buffer
);
6294 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6295 minibuf_selected_window
= data
->minibuf_selected_window
;
6297 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6300 /* Mark all windows now on frame as deleted
6301 by setting their buffers to nil. */
6304 delete_all_subwindows (register struct window
*w
)
6306 if (!NILP (w
->next
))
6307 delete_all_subwindows (XWINDOW (w
->next
));
6308 if (!NILP (w
->vchild
))
6309 delete_all_subwindows (XWINDOW (w
->vchild
));
6310 if (!NILP (w
->hchild
))
6311 delete_all_subwindows (XWINDOW (w
->hchild
));
6313 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6315 if (!NILP (w
->buffer
))
6318 /* We set all three of these fields to nil, to make sure that we can
6319 distinguish this dead window from any live window. Live leaf
6320 windows will have buffer set, and combination windows will have
6321 vchild or hchild set. */
6326 Vwindow_list
= Qnil
;
6330 count_windows (register struct window
*window
)
6332 register int count
= 1;
6333 if (!NILP (window
->next
))
6334 count
+= count_windows (XWINDOW (window
->next
));
6335 if (!NILP (window
->vchild
))
6336 count
+= count_windows (XWINDOW (window
->vchild
));
6337 if (!NILP (window
->hchild
))
6338 count
+= count_windows (XWINDOW (window
->hchild
));
6343 /* Fill vector FLAT with leaf windows under W, starting at index I.
6344 Value is last index + 1. */
6347 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
6351 if (!NILP (w
->hchild
))
6352 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6353 else if (!NILP (w
->vchild
))
6354 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6358 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6365 /* Return a pointer to the glyph W's physical cursor is on. Value is
6366 null if W's current matrix is invalid, so that no meaningfull glyph
6370 get_phys_cursor_glyph (struct window
*w
)
6372 struct glyph_row
*row
;
6373 struct glyph
*glyph
;
6375 if (w
->phys_cursor
.vpos
>= 0
6376 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6377 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6379 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6380 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6389 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6391 register struct saved_window
*p
;
6392 register struct window
*w
;
6393 register Lisp_Object tem
;
6395 for (;!NILP (window
); window
= w
->next
)
6397 p
= SAVED_WINDOW_N (vector
, i
);
6398 w
= XWINDOW (window
);
6400 XSETFASTINT (w
->temslot
, i
); i
++;
6402 p
->buffer
= w
->buffer
;
6403 p
->left_col
= w
->left_col
;
6404 p
->top_line
= w
->top_line
;
6405 p
->total_cols
= w
->total_cols
;
6406 p
->total_lines
= w
->total_lines
;
6407 p
->hscroll
= w
->hscroll
;
6408 p
->min_hscroll
= w
->min_hscroll
;
6409 p
->display_table
= w
->display_table
;
6410 p
->orig_top_line
= w
->orig_top_line
;
6411 p
->orig_total_lines
= w
->orig_total_lines
;
6412 p
->left_margin_cols
= w
->left_margin_cols
;
6413 p
->right_margin_cols
= w
->right_margin_cols
;
6414 p
->left_fringe_width
= w
->left_fringe_width
;
6415 p
->right_fringe_width
= w
->right_fringe_width
;
6416 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6417 p
->scroll_bar_width
= w
->scroll_bar_width
;
6418 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6419 p
->dedicated
= w
->dedicated
;
6420 p
->resize_proportionally
= w
->resize_proportionally
;
6421 if (!NILP (w
->buffer
))
6423 /* Save w's value of point in the window configuration.
6424 If w is the selected window, then get the value of point
6425 from the buffer; pointm is garbage in the selected window. */
6426 if (EQ (window
, selected_window
))
6428 p
->pointm
= Fmake_marker ();
6429 set_marker_both (p
->pointm
, w
->buffer
,
6430 BUF_PT (XBUFFER (w
->buffer
)),
6431 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6434 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6436 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6437 p
->start_at_line_beg
= w
->start_at_line_beg
;
6439 tem
= XBUFFER (w
->buffer
)->mark
;
6440 p
->mark
= Fcopy_marker (tem
, Qnil
);
6447 p
->start_at_line_beg
= Qnil
;
6450 if (NILP (w
->parent
))
6453 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6458 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6460 if (!NILP (w
->vchild
))
6461 i
= save_window_save (w
->vchild
, vector
, i
);
6462 if (!NILP (w
->hchild
))
6463 i
= save_window_save (w
->hchild
, vector
, i
);
6469 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6470 Scurrent_window_configuration
, 0, 1, 0,
6471 doc
: /* Return an object representing the current window configuration of FRAME.
6472 If FRAME is nil or omitted, use the selected frame.
6473 This describes the number of windows, their sizes and current buffers,
6474 and for each displayed buffer, where display starts, and the positions of
6475 point and mark. An exception is made for point in the current buffer:
6476 its value is -not- saved.
6477 This also records the currently selected frame, and FRAME's focus
6478 redirection (see `redirect-frame-focus'). */)
6482 register Lisp_Object tem
;
6483 register int n_windows
;
6484 register struct save_window_data
*data
;
6489 frame
= selected_frame
;
6490 CHECK_LIVE_FRAME (frame
);
6493 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6494 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6495 PVEC_WINDOW_CONFIGURATION
);
6497 data
->frame_cols
= FRAME_COLS (f
);
6498 data
->frame_lines
= FRAME_LINES (f
);
6499 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6500 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6501 data
->selected_frame
= selected_frame
;
6502 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6503 XSETBUFFER (data
->current_buffer
, current_buffer
);
6504 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6505 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6506 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6507 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6508 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6509 data
->saved_windows
= tem
;
6510 for (i
= 0; i
< n_windows
; i
++)
6511 XVECTOR (tem
)->contents
[i
]
6512 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6513 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6514 XSETWINDOW_CONFIGURATION (tem
, data
);
6518 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6520 doc
: /* Execute BODY, preserving window sizes and contents.
6521 Return the value of the last form in BODY.
6522 Restore which buffer appears in which window, where display starts,
6523 and the value of point and mark for each window.
6524 Also restore the choice of selected window.
6525 Also restore which buffer is current.
6526 Does not restore the value of point in current buffer.
6527 usage: (save-window-excursion BODY...) */)
6531 register Lisp_Object val
;
6532 register int count
= SPECPDL_INDEX ();
6534 record_unwind_protect (Fset_window_configuration
,
6535 Fcurrent_window_configuration (Qnil
));
6536 val
= Fprogn (args
);
6537 return unbind_to (count
, val
);
6542 /***********************************************************************
6544 ***********************************************************************/
6547 window_tree (struct window
*w
)
6549 Lisp_Object tail
= Qnil
;
6550 Lisp_Object result
= Qnil
;
6557 if (!NILP (w
->hchild
))
6558 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6559 window_tree (XWINDOW (w
->hchild
))));
6560 else if (!NILP (w
->vchild
))
6561 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6562 window_tree (XWINDOW (w
->vchild
))));
6566 result
= tail
= Fcons (wn
, Qnil
);
6570 XSETCDR (tail
, Fcons (wn
, Qnil
));
6574 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6582 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6584 doc
: /* Return the window tree for frame FRAME.
6586 The return value is a list of the form (ROOT MINI), where ROOT
6587 represents the window tree of the frame's root window, and MINI
6588 is the frame's minibuffer window.
6590 If the root window is not split, ROOT is the root window itself.
6591 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6592 horizontal split, and t for a vertical split, EDGES gives the combined
6593 size and position of the subwindows in the split, and the rest of the
6594 elements are the subwindows in the split. Each of the subwindows may
6595 again be a window or a list representing a window split, and so on.
6596 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6598 If FRAME is nil or omitted, return information on the currently
6606 frame
= selected_frame
;
6608 CHECK_FRAME (frame
);
6611 if (!FRAME_LIVE_P (f
))
6614 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6618 /***********************************************************************
6620 ***********************************************************************/
6622 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6624 doc
: /* Set width of marginal areas of window WINDOW.
6625 If WINDOW is nil, set margins of the currently selected window.
6626 Second arg LEFT-WIDTH specifies the number of character cells to
6627 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6628 does the same for the right marginal area. A nil width parameter
6629 means no margin. */)
6630 (window
, left_width
, right_width
)
6631 Lisp_Object window
, left_width
, right_width
;
6633 struct window
*w
= decode_window (window
);
6635 /* Translate negative or zero widths to nil.
6636 Margins that are too wide have to be checked elsewhere. */
6638 if (!NILP (left_width
))
6640 CHECK_NUMBER (left_width
);
6641 if (XINT (left_width
) <= 0)
6645 if (!NILP (right_width
))
6647 CHECK_NUMBER (right_width
);
6648 if (XINT (right_width
) <= 0)
6652 if (!EQ (w
->left_margin_cols
, left_width
)
6653 || !EQ (w
->right_margin_cols
, right_width
))
6655 w
->left_margin_cols
= left_width
;
6656 w
->right_margin_cols
= right_width
;
6658 adjust_window_margins (w
);
6660 ++windows_or_buffers_changed
;
6661 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6668 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6670 doc
: /* Get width of marginal areas of window WINDOW.
6671 If WINDOW is omitted or nil, use the currently selected window.
6672 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6673 If a marginal area does not exist, its width will be returned
6678 struct window
*w
= decode_window (window
);
6679 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6684 /***********************************************************************
6686 ***********************************************************************/
6688 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6690 doc
: /* Set the fringe widths of window WINDOW.
6691 If WINDOW is nil, set the fringe widths of the currently selected
6693 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6694 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6695 fringe width. If a fringe width arg is nil, that means to use the
6696 frame's default fringe width. Default fringe widths can be set with
6697 the command `set-fringe-style'.
6698 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6699 outside of the display margins. By default, fringes are drawn between
6700 display marginal areas and the text area. */)
6701 (window
, left_width
, right_width
, outside_margins
)
6702 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6704 struct window
*w
= decode_window (window
);
6706 if (!NILP (left_width
))
6707 CHECK_NATNUM (left_width
);
6708 if (!NILP (right_width
))
6709 CHECK_NATNUM (right_width
);
6711 /* Do nothing on a tty. */
6712 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6713 && (!EQ (w
->left_fringe_width
, left_width
)
6714 || !EQ (w
->right_fringe_width
, right_width
)
6715 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6717 w
->left_fringe_width
= left_width
;
6718 w
->right_fringe_width
= right_width
;
6719 w
->fringes_outside_margins
= outside_margins
;
6721 adjust_window_margins (w
);
6723 clear_glyph_matrix (w
->current_matrix
);
6724 w
->window_end_valid
= Qnil
;
6726 ++windows_or_buffers_changed
;
6727 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6734 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6736 doc
: /* Get width of fringes of window WINDOW.
6737 If WINDOW is omitted or nil, use the currently selected window.
6738 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6742 struct window
*w
= decode_window (window
);
6744 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6745 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6746 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6747 ? Qt
: Qnil
), Qnil
)));
6752 /***********************************************************************
6754 ***********************************************************************/
6756 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6758 doc
: /* Set width and type of scroll bars of window WINDOW.
6759 If window is nil, set scroll bars of the currently selected window.
6760 Second parameter WIDTH specifies the pixel width for the scroll bar;
6761 this is automatically adjusted to a multiple of the frame column width.
6762 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6763 bar: left, right, or nil.
6764 If WIDTH is nil, use the frame's scroll-bar width.
6765 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6766 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6767 (window
, width
, vertical_type
, horizontal_type
)
6768 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6770 struct window
*w
= decode_window (window
);
6774 CHECK_NATNUM (width
);
6776 if (XINT (width
) == 0)
6777 vertical_type
= Qnil
;
6780 if (!(NILP (vertical_type
)
6781 || EQ (vertical_type
, Qleft
)
6782 || EQ (vertical_type
, Qright
)
6783 || EQ (vertical_type
, Qt
)))
6784 error ("Invalid type of vertical scroll bar");
6786 if (!EQ (w
->scroll_bar_width
, width
)
6787 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6789 w
->scroll_bar_width
= width
;
6790 w
->vertical_scroll_bar_type
= vertical_type
;
6792 adjust_window_margins (w
);
6794 clear_glyph_matrix (w
->current_matrix
);
6795 w
->window_end_valid
= Qnil
;
6797 ++windows_or_buffers_changed
;
6798 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6805 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6807 doc
: /* Get width and type of scroll bars of window WINDOW.
6808 If WINDOW is omitted or nil, use the currently selected window.
6809 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6810 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6815 struct window
*w
= decode_window (window
);
6816 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6817 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6818 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6819 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6820 Fcons (w
->vertical_scroll_bar_type
,
6821 Fcons (Qnil
, Qnil
))));
6826 /***********************************************************************
6828 ***********************************************************************/
6830 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6831 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6832 Use the selected window if WINDOW is nil or omitted.
6833 Normally, value is a multiple of the canonical character height of WINDOW;
6834 optional second arg PIXELS-P means value is measured in pixels. */)
6836 Lisp_Object window
, pixels_p
;
6843 window
= selected_window
;
6845 CHECK_WINDOW (window
);
6846 w
= XWINDOW (window
);
6847 f
= XFRAME (w
->frame
);
6849 if (FRAME_WINDOW_P (f
))
6850 result
= (NILP (pixels_p
)
6851 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6852 : make_number (-w
->vscroll
));
6854 result
= make_number (0);
6859 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6861 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6862 WINDOW nil means use the selected window. Normally, VSCROLL is a
6863 non-negative multiple of the canonical character height of WINDOW;
6864 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6865 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6866 corresponds to an integral number of pixels. The return value is the
6867 result of this rounding.
6868 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6869 (window
, vscroll
, pixels_p
)
6870 Lisp_Object window
, vscroll
, pixels_p
;
6876 window
= selected_window
;
6878 CHECK_WINDOW (window
);
6879 CHECK_NUMBER_OR_FLOAT (vscroll
);
6881 w
= XWINDOW (window
);
6882 f
= XFRAME (w
->frame
);
6884 if (FRAME_WINDOW_P (f
))
6886 int old_dy
= w
->vscroll
;
6888 w
->vscroll
= - (NILP (pixels_p
)
6889 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6890 : XFLOATINT (vscroll
));
6891 w
->vscroll
= min (w
->vscroll
, 0);
6893 if (w
->vscroll
!= old_dy
)
6895 /* Adjust glyph matrix of the frame if the virtual display
6896 area becomes larger than before. */
6897 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6900 /* Prevent redisplay shortcuts. */
6901 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6905 return Fwindow_vscroll (window
, pixels_p
);
6909 /* Call FN for all leaf windows on frame F. FN is called with the
6910 first argument being a pointer to the leaf window, and with
6911 additional argument USER_DATA. Stops when FN returns 0. */
6914 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *), void *user_data
)
6916 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6917 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6918 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6922 /* Helper function for foreach_window. Call FN for all leaf windows
6923 reachable from W. FN is called with the first argument being a
6924 pointer to the leaf window, and with additional argument USER_DATA.
6925 Stop when FN returns 0. Value is 0 if stopped by FN. */
6928 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6932 for (cont
= 1; w
&& cont
;)
6934 if (!NILP (w
->hchild
))
6935 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6936 else if (!NILP (w
->vchild
))
6937 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6939 cont
= fn (w
, user_data
);
6941 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6948 /* Freeze or unfreeze the window start of W unless it is a
6949 mini-window or the selected window. FREEZE_P non-null means freeze
6950 the window start. */
6953 freeze_window_start (struct window
*w
, void *freeze_p
)
6955 if (MINI_WINDOW_P (w
)
6956 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6957 && (w
== XWINDOW (selected_window
)
6958 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6959 && ! NILP (Vminibuf_scroll_window
)
6960 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6963 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6968 /* Freeze or unfreeze the window starts of all leaf windows on frame
6969 F, except the selected window and a mini-window. FREEZE_P non-zero
6970 means freeze the window start. */
6973 freeze_window_starts (struct frame
*f
, int freeze_p
)
6975 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6979 /***********************************************************************
6981 ***********************************************************************/
6983 /* Return 1 if window configurations C1 and C2
6984 describe the same state of affairs. This is used by Fequal. */
6987 compare_window_configurations (Lisp_Object c1
, Lisp_Object c2
, int ignore_positions
)
6989 register struct save_window_data
*d1
, *d2
;
6990 struct Lisp_Vector
*sw1
, *sw2
;
6993 CHECK_WINDOW_CONFIGURATION (c1
);
6994 CHECK_WINDOW_CONFIGURATION (c2
);
6996 d1
= (struct save_window_data
*) XVECTOR (c1
);
6997 d2
= (struct save_window_data
*) XVECTOR (c2
);
6998 sw1
= XVECTOR (d1
->saved_windows
);
6999 sw2
= XVECTOR (d2
->saved_windows
);
7001 if (d1
->frame_cols
!= d2
->frame_cols
)
7003 if (d1
->frame_lines
!= d2
->frame_lines
)
7005 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
7007 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
7009 /* Don't compare the current_window field directly.
7010 Instead see w1_is_current and w2_is_current, below. */
7011 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
7013 if (! ignore_positions
)
7015 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
7017 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
7020 /* Don't compare the root_window field.
7021 We don't require the two configurations
7022 to use the same window object,
7023 and the two root windows must be equivalent
7024 if everything else compares equal. */
7025 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
7028 /* Verify that the two confis have the same number of windows. */
7029 if (sw1
->size
!= sw2
->size
)
7032 for (i
= 0; i
< sw1
->size
; i
++)
7034 struct saved_window
*p1
, *p2
;
7035 int w1_is_current
, w2_is_current
;
7037 p1
= SAVED_WINDOW_N (sw1
, i
);
7038 p2
= SAVED_WINDOW_N (sw2
, i
);
7040 /* Verify that the current windows in the two
7041 configurations correspond to each other. */
7042 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7043 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7045 if (w1_is_current
!= w2_is_current
)
7048 /* Verify that the corresponding windows do match. */
7049 if (! EQ (p1
->buffer
, p2
->buffer
))
7051 if (! EQ (p1
->left_col
, p2
->left_col
))
7053 if (! EQ (p1
->top_line
, p2
->top_line
))
7055 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7057 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7059 if (! EQ (p1
->display_table
, p2
->display_table
))
7061 if (! EQ (p1
->parent
, p2
->parent
))
7063 if (! EQ (p1
->prev
, p2
->prev
))
7065 if (! ignore_positions
)
7067 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7069 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7071 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7073 if (NILP (Fequal (p1
->start
, p2
->start
)))
7075 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7077 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7080 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7082 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7084 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7086 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7088 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7090 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7092 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7099 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7100 Scompare_window_configurations
, 2, 2, 0,
7101 doc
: /* Compare two window configurations as regards the structure of windows.
7102 This function ignores details such as the values of point and mark
7103 and scrolling positions. */)
7107 if (compare_window_configurations (x
, y
, 1))
7113 init_window_once (void)
7115 struct frame
*f
= make_initial_frame ();
7116 XSETFRAME (selected_frame
, f
);
7117 Vterminal_frame
= selected_frame
;
7118 minibuf_window
= f
->minibuffer_window
;
7119 selected_window
= f
->selected_window
;
7120 last_nonminibuf_frame
= f
;
7122 window_initialized
= 1;
7128 Vwindow_list
= Qnil
;
7132 syms_of_window (void)
7134 Qscroll_up
= intern_c_string ("scroll-up");
7135 staticpro (&Qscroll_up
);
7137 Qscroll_down
= intern_c_string ("scroll-down");
7138 staticpro (&Qscroll_down
);
7140 Qscroll_command
= intern_c_string ("scroll-command");
7141 staticpro (&Qscroll_command
);
7143 Fput (Qscroll_up
, Qscroll_command
, Qt
);
7144 Fput (Qscroll_down
, Qscroll_command
, Qt
);
7146 Qwindow_size_fixed
= intern_c_string ("window-size-fixed");
7147 staticpro (&Qwindow_size_fixed
);
7148 Fset (Qwindow_size_fixed
, Qnil
);
7150 staticpro (&Qwindow_configuration_change_hook
);
7151 Qwindow_configuration_change_hook
7152 = intern_c_string ("window-configuration-change-hook");
7154 Qwindowp
= intern_c_string ("windowp");
7155 staticpro (&Qwindowp
);
7157 Qwindow_configuration_p
= intern_c_string ("window-configuration-p");
7158 staticpro (&Qwindow_configuration_p
);
7160 Qwindow_live_p
= intern_c_string ("window-live-p");
7161 staticpro (&Qwindow_live_p
);
7163 Qdisplay_buffer
= intern_c_string ("display-buffer");
7164 staticpro (&Qdisplay_buffer
);
7166 Qtemp_buffer_show_hook
= intern_c_string ("temp-buffer-show-hook");
7167 staticpro (&Qtemp_buffer_show_hook
);
7169 staticpro (&Vwindow_list
);
7171 minibuf_selected_window
= Qnil
;
7172 staticpro (&minibuf_selected_window
);
7174 window_scroll_pixel_based_preserve_x
= -1;
7175 window_scroll_pixel_based_preserve_y
= -1;
7176 window_scroll_preserve_hpos
= -1;
7177 window_scroll_preserve_vpos
= -1;
7179 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7180 doc
: /* Non-nil means call as function to display a help buffer.
7181 The function is called with one argument, the buffer to be displayed.
7182 Used by `with-output-to-temp-buffer'.
7183 If this function is used, then it must do the entire job of showing
7184 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7185 Vtemp_buffer_show_function
= Qnil
;
7187 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7188 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7189 Vminibuf_scroll_window
= Qnil
;
7191 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7192 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7193 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7194 is displayed in the `mode-line' face. */);
7195 mode_line_in_non_selected_windows
= 1;
7197 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7198 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7199 Vother_window_scroll_buffer
= Qnil
;
7201 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7202 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7203 auto_window_vscroll_p
= 1;
7205 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7206 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7207 next_screen_context_lines
= 2;
7209 DEFVAR_INT ("window-min-height", &window_min_height
,
7210 doc
: /* Allow deleting windows less than this tall.
7211 The value is measured in line units. If a window wants a modeline it
7212 is counted as one line.
7214 Emacs honors settings of this variable when enlarging or shrinking
7215 windows vertically. A value less than 1 is invalid. */);
7216 window_min_height
= 4;
7218 DEFVAR_INT ("window-min-width", &window_min_width
,
7219 doc
: /* Allow deleting windows less than this wide.
7220 The value is measured in characters and includes any fringes or
7223 Emacs honors settings of this variable when enlarging or shrinking
7224 windows horizontally. A value less than 2 is invalid. */);
7225 window_min_width
= 10;
7227 DEFVAR_LISP ("scroll-preserve-screen-position",
7228 &Vscroll_preserve_screen_position
,
7229 doc
: /* *Controls if scroll commands move point to keep its screen position unchanged.
7230 A value of nil means point does not keep its screen position except
7231 at the scroll margin or window boundary respectively.
7232 A value of t means point keeps its screen position if the scroll
7233 command moved it vertically out of the window, e.g. when scrolling
7235 Any other value means point always keeps its screen position.
7236 Scroll commands should have the `scroll-command' property
7237 on their symbols to be controlled by this variable. */);
7238 Vscroll_preserve_screen_position
= Qnil
;
7240 DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type
,
7241 doc
: /* Type of marker to use for `window-point'. */);
7242 Vwindow_point_insertion_type
= Qnil
;
7244 DEFVAR_LISP ("window-configuration-change-hook",
7245 &Vwindow_configuration_change_hook
,
7246 doc
: /* Functions to call when window configuration changes.
7247 The buffer-local part is run once per window, with the relevant window
7248 selected; while the global part is run only once for the modified frame,
7249 with the relevant frame selected. */);
7250 Vwindow_configuration_change_hook
= Qnil
;
7252 DEFVAR_LISP ("recenter-redisplay", &Vrecenter_redisplay
,
7253 doc
: /* If non-nil, then the `recenter' command with a nil argument
7254 will redraw the entire frame; the special value `tty' causes the
7255 frame to be redrawn only if it is a tty frame. */);
7256 Vrecenter_redisplay
= Qtty
;
7259 defsubr (&Sselected_window
);
7260 defsubr (&Sminibuffer_window
);
7261 defsubr (&Swindow_minibuffer_p
);
7262 defsubr (&Swindowp
);
7263 defsubr (&Swindow_live_p
);
7264 defsubr (&Spos_visible_in_window_p
);
7265 defsubr (&Swindow_line_height
);
7266 defsubr (&Swindow_buffer
);
7267 defsubr (&Swindow_height
);
7268 defsubr (&Swindow_width
);
7269 defsubr (&Swindow_full_width_p
);
7270 defsubr (&Swindow_hscroll
);
7271 defsubr (&Sset_window_hscroll
);
7272 defsubr (&Swindow_redisplay_end_trigger
);
7273 defsubr (&Sset_window_redisplay_end_trigger
);
7274 defsubr (&Swindow_edges
);
7275 defsubr (&Swindow_pixel_edges
);
7276 defsubr (&Swindow_absolute_pixel_edges
);
7277 defsubr (&Swindow_inside_edges
);
7278 defsubr (&Swindow_inside_pixel_edges
);
7279 defsubr (&Swindow_inside_absolute_pixel_edges
);
7280 defsubr (&Scoordinates_in_window_p
);
7281 defsubr (&Swindow_at
);
7282 defsubr (&Swindow_point
);
7283 defsubr (&Swindow_start
);
7284 defsubr (&Swindow_end
);
7285 defsubr (&Sset_window_point
);
7286 defsubr (&Sset_window_start
);
7287 defsubr (&Swindow_dedicated_p
);
7288 defsubr (&Sset_window_dedicated_p
);
7289 defsubr (&Swindow_display_table
);
7290 defsubr (&Sset_window_display_table
);
7291 defsubr (&Snext_window
);
7292 defsubr (&Sprevious_window
);
7293 defsubr (&Sother_window
);
7294 defsubr (&Sget_lru_window
);
7295 defsubr (&Sget_largest_window
);
7296 defsubr (&Sget_buffer_window
);
7297 defsubr (&Sdelete_other_windows
);
7298 defsubr (&Sdelete_windows_on
);
7299 defsubr (&Sreplace_buffer_in_windows
);
7300 defsubr (&Sdelete_window
);
7301 defsubr (&Sset_window_buffer
);
7302 defsubr (&Sselect_window
);
7303 defsubr (&Sforce_window_update
);
7304 defsubr (&Ssplit_window
);
7305 defsubr (&Senlarge_window
);
7306 defsubr (&Sshrink_window
);
7307 defsubr (&Sadjust_window_trailing_edge
);
7308 defsubr (&Sscroll_up
);
7309 defsubr (&Sscroll_down
);
7310 defsubr (&Sscroll_left
);
7311 defsubr (&Sscroll_right
);
7312 defsubr (&Sother_window_for_scrolling
);
7313 defsubr (&Sscroll_other_window
);
7314 defsubr (&Sminibuffer_selected_window
);
7315 defsubr (&Srecenter
);
7316 defsubr (&Swindow_text_height
);
7317 defsubr (&Smove_to_window_line
);
7318 defsubr (&Swindow_configuration_p
);
7319 defsubr (&Swindow_configuration_frame
);
7320 defsubr (&Sset_window_configuration
);
7321 defsubr (&Scurrent_window_configuration
);
7322 defsubr (&Ssave_window_excursion
);
7323 defsubr (&Swindow_tree
);
7324 defsubr (&Sset_window_margins
);
7325 defsubr (&Swindow_margins
);
7326 defsubr (&Sset_window_fringes
);
7327 defsubr (&Swindow_fringes
);
7328 defsubr (&Sset_window_scroll_bars
);
7329 defsubr (&Swindow_scroll_bars
);
7330 defsubr (&Swindow_vscroll
);
7331 defsubr (&Sset_window_vscroll
);
7332 defsubr (&Scompare_window_configurations
);
7333 defsubr (&Swindow_list
);
7334 defsubr (&Swindow_parameters
);
7335 defsubr (&Swindow_parameter
);
7336 defsubr (&Sset_window_parameter
);
7341 keys_of_window (void)
7343 initial_define_key (control_x_map
, '1', "delete-other-windows");
7344 initial_define_key (control_x_map
, '2', "split-window");
7345 initial_define_key (control_x_map
, '0', "delete-window");
7346 initial_define_key (control_x_map
, 'o', "other-window");
7347 initial_define_key (control_x_map
, '^', "enlarge-window");
7348 initial_define_key (control_x_map
, '<', "scroll-left");
7349 initial_define_key (control_x_map
, '>', "scroll-right");
7351 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
7352 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7353 initial_define_key (meta_map
, 'v', "scroll-down-command");
7356 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7357 (do not change this comment) */