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
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/>. */
35 #include "dispextern.h"
36 #include "blockinput.h"
37 #include "intervals.h"
38 #include "termhooks.h" /* For FRAME_TERMINAL. */
42 #endif /* HAVE_X_WINDOWS */
54 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
55 Lisp_Object Qdisplay_buffer
;
56 Lisp_Object Qscroll_up
, Qscroll_down
;
57 Lisp_Object Qwindow_size_fixed
;
59 extern Lisp_Object Qleft_margin
, Qright_margin
;
61 static int displayed_window_lines
P_ ((struct window
*));
62 static struct window
*decode_window
P_ ((Lisp_Object
));
63 static int count_windows
P_ ((struct window
*));
64 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
65 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
66 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
67 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
68 static int window_min_size_1
P_ ((struct window
*, int, int));
69 static int window_min_size_2
P_ ((struct window
*, int, int));
70 static int window_min_size
P_ ((struct window
*, int, int, int, int *));
71 static void size_window
P_ ((Lisp_Object
, int, int, int, int, int));
72 static int freeze_window_start
P_ ((struct window
*, void *));
73 static int window_fixed_size_p
P_ ((struct window
*, int, int));
74 static void enlarge_window
P_ ((Lisp_Object
, int, int));
75 static Lisp_Object window_list
P_ ((void));
76 static int add_window_to_list
P_ ((struct window
*, void *));
77 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
79 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
81 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
83 static int foreach_window_1
P_ ((struct window
*,
84 int (* fn
) (struct window
*, void *),
86 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
88 /* This is the window in which the terminal's cursor should
89 be left when nothing is being done with it. This must
90 always be a leaf window, and its buffer is selected by
91 the top level editing loop at the end of each command.
93 This value is always the same as
94 FRAME_SELECTED_WINDOW (selected_frame). */
96 Lisp_Object selected_window
;
98 /* A list of all windows for use by next_window and Fwindow_list.
99 Functions creating or deleting windows should invalidate this cache
100 by setting it to nil. */
102 Lisp_Object Vwindow_list
;
104 /* The mini-buffer window of the selected frame.
105 Note that you cannot test for mini-bufferness of an arbitrary window
106 by comparing against this; but you can test for mini-bufferness of
107 the selected window. */
109 Lisp_Object minibuf_window
;
111 /* Non-nil means it is the window whose mode line should be
112 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Non-nil means it is the window for C-M-v to scroll
117 when the mini-buffer is selected. */
119 Lisp_Object Vminibuf_scroll_window
;
121 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
123 Lisp_Object Vother_window_scroll_buffer
;
125 /* Non-nil means it's function to call to display temp buffers. */
127 Lisp_Object Vtemp_buffer_show_function
;
129 /* Non-zero means line and page scrolling on tall lines (with images)
130 does partial scrolling by modifying window-vscroll. */
132 int auto_window_vscroll_p
;
134 /* Non-zero means to use mode-line-inactive face in all windows but the
135 selected-window and the minibuffer-scroll-window when the
136 minibuffer is active. */
137 int mode_line_in_non_selected_windows
;
139 /* If a window gets smaller than either of these, it is removed. */
141 EMACS_INT window_min_height
;
142 EMACS_INT window_min_width
;
144 /* Hook run at end of temp_output_buffer_show. */
146 Lisp_Object Qtemp_buffer_show_hook
;
148 /* Number of lines of continuity in scrolling by screenfuls. */
150 EMACS_INT next_screen_context_lines
;
152 /* Incremented for each window created. */
154 static int sequence_number
;
156 /* Nonzero after init_window_once has finished. */
158 static int window_initialized
;
160 /* Hook to run when window config changes. */
162 static Lisp_Object Qwindow_configuration_change_hook
;
163 static Lisp_Object Vwindow_configuration_change_hook
;
165 /* Non-nil means scroll commands try to put point
166 at the same screen height as previously. */
168 Lisp_Object Vscroll_preserve_screen_position
;
170 /* Non-nil means that text is inserted before window's markers. */
172 Lisp_Object Vwindow_point_insertion_type
;
174 /* Incremented by 1 whenever a window is deleted. */
176 int window_deletion_count
;
178 /* Used by the function window_scroll_pixel_based */
180 static int window_scroll_pixel_based_preserve_x
;
181 static int window_scroll_pixel_based_preserve_y
;
183 /* Same for window_scroll_line_based. */
185 static int window_scroll_preserve_hpos
;
186 static int window_scroll_preserve_vpos
;
188 #if 0 /* This isn't used anywhere. */
189 /* Nonzero means we can split a frame even if it is "unsplittable". */
190 static int inhibit_frame_unsplittable
;
193 extern EMACS_INT scroll_margin
;
195 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
197 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
198 doc
: /* Returns t if OBJECT is a window. */)
202 return WINDOWP (object
) ? Qt
: Qnil
;
205 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
206 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
210 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
217 register struct window
*p
;
219 p
= allocate_window ();
221 XSETFASTINT (p
->sequence_number
, sequence_number
);
222 XSETFASTINT (p
->left_col
, 0);
223 XSETFASTINT (p
->top_line
, 0);
224 XSETFASTINT (p
->total_lines
, 0);
225 XSETFASTINT (p
->total_cols
, 0);
226 XSETFASTINT (p
->hscroll
, 0);
227 XSETFASTINT (p
->min_hscroll
, 0);
228 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
229 p
->start
= Fmake_marker ();
230 p
->pointm
= Fmake_marker ();
231 XSETFASTINT (p
->use_time
, 0);
233 p
->display_table
= Qnil
;
235 p
->window_parameters
= Qnil
;
236 p
->pseudo_window_p
= 0;
237 bzero (&p
->cursor
, sizeof (p
->cursor
));
238 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
239 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
240 p
->desired_matrix
= p
->current_matrix
= 0;
241 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
242 p
->phys_cursor_type
= -1;
243 p
->phys_cursor_width
= -1;
244 p
->must_be_updated_p
= 0;
245 XSETFASTINT (p
->window_end_vpos
, 0);
246 XSETFASTINT (p
->window_end_pos
, 0);
247 p
->window_end_valid
= Qnil
;
250 XSETFASTINT (p
->last_point
, 0);
251 p
->frozen_window_start_p
= 0;
252 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
253 p
->left_margin_cols
= Qnil
;
254 p
->right_margin_cols
= Qnil
;
255 p
->left_fringe_width
= Qnil
;
256 p
->right_fringe_width
= Qnil
;
257 p
->fringes_outside_margins
= Qnil
;
258 p
->scroll_bar_width
= Qnil
;
259 p
->vertical_scroll_bar_type
= Qt
;
260 p
->resize_proportionally
= Qnil
;
266 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
267 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
270 return selected_window
;
273 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
274 doc
: /* Return the window used now for minibuffers.
275 If the optional argument FRAME is specified, return the minibuffer window
276 used by that frame. */)
281 frame
= selected_frame
;
282 CHECK_LIVE_FRAME (frame
);
283 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
286 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
287 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
288 WINDOW defaults to the selected window. */)
292 struct window
*w
= decode_window (window
);
293 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
297 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
298 Spos_visible_in_window_p
, 0, 3, 0,
299 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
300 Return nil if that position is scrolled vertically out of view.
301 If a character is only partially visible, nil is returned, unless the
302 optional argument PARTIALLY is non-nil.
303 If POS is only out of view because of horizontal scrolling, return non-nil.
304 If POS is t, it specifies the position of the last visible glyph in WINDOW.
305 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
307 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
308 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
309 where X and Y are the pixel coordinates relative to the top left corner
310 of the window. The remaining elements are omitted if the character after
311 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
312 off-window at the top and bottom of the row, ROWH is the height of the
313 display row, and VPOS is the row number (0-based) containing POS. */)
314 (pos
, window
, partially
)
315 Lisp_Object pos
, window
, partially
;
317 register struct window
*w
;
319 register struct buffer
*buf
;
321 Lisp_Object in_window
= Qnil
;
322 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
325 w
= decode_window (window
);
326 buf
= XBUFFER (w
->buffer
);
327 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
331 else if (!NILP (pos
))
333 CHECK_NUMBER_COERCE_MARKER (pos
);
336 else if (w
== XWINDOW (selected_window
))
339 posint
= XMARKER (w
->pointm
)->charpos
;
341 /* If position is above window start or outside buffer boundaries,
342 or if window start is out of range, position is not visible. */
344 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
345 && CHARPOS (top
) >= BUF_BEGV (buf
)
346 && CHARPOS (top
) <= BUF_ZV (buf
)
347 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
348 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
351 if (!NILP (in_window
) && !NILP (partially
))
353 Lisp_Object part
= Qnil
;
355 part
= list4 (make_number (rtop
), make_number (rbot
),
356 make_number (rowh
), make_number (vpos
));
357 in_window
= Fcons (make_number (x
),
358 Fcons (make_number (y
), part
));
364 DEFUN ("window-line-height", Fwindow_line_height
,
365 Swindow_line_height
, 0, 2, 0,
366 doc
: /* Return height in pixels of text line LINE in window WINDOW.
367 If WINDOW is nil or omitted, use selected window.
369 Return height of current line if LINE is omitted or nil. Return height of
370 header or mode line if LINE is `header-line' and `mode-line'.
371 Otherwise, LINE is a text line number starting from 0. A negative number
372 counts from the end of the window.
374 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
375 in pixels of the visible part of the line, VPOS and YPOS are the
376 vertical position in lines and pixels of the line, relative to the top
377 of the first text line, and OFFBOT is the number of off-window pixels at
378 the bottom of the text line. If there are off-window pixels at the top
379 of the (first) text line, YPOS is negative.
381 Return nil if window display is not up-to-date. In that case, use
382 `pos-visible-in-window-p' to obtain the information. */)
384 Lisp_Object line
, window
;
386 register struct window
*w
;
387 register struct buffer
*b
;
388 struct glyph_row
*row
, *end_row
;
389 int max_y
, crop
, i
, n
;
391 w
= decode_window (window
);
394 || w
->pseudo_window_p
)
397 CHECK_BUFFER (w
->buffer
);
398 b
= XBUFFER (w
->buffer
);
400 /* Fail if current matrix is not up-to-date. */
401 if (NILP (w
->window_end_valid
)
402 || current_buffer
->clip_changed
403 || current_buffer
->prevent_redisplay_optimizations_p
404 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
405 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
411 if (i
< 0 || i
>= w
->current_matrix
->nrows
412 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
414 max_y
= window_text_bottom_y (w
);
418 if (EQ (line
, Qheader_line
))
420 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
422 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
425 return list4 (make_number (row
->height
),
426 make_number (0), make_number (0),
430 if (EQ (line
, Qmode_line
))
432 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
435 return list4 (make_number (row
->height
),
436 make_number (0), /* not accurate */
437 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
438 + window_text_bottom_y (w
)),
445 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
446 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
447 max_y
= window_text_bottom_y (w
);
450 while ((n
< 0 || i
< n
)
451 && row
<= end_row
&& row
->enabled_p
452 && row
->y
+ row
->height
< max_y
)
455 if (row
> end_row
|| !row
->enabled_p
)
467 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
468 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
470 make_number (row
->y
),
476 static struct window
*
477 decode_window (window
)
478 register Lisp_Object window
;
481 return XWINDOW (selected_window
);
483 CHECK_LIVE_WINDOW (window
);
484 return XWINDOW (window
);
487 static struct window
*
488 decode_any_window (window
)
489 register Lisp_Object window
;
492 return XWINDOW (selected_window
);
494 CHECK_WINDOW (window
);
495 return XWINDOW (window
);
498 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
499 doc
: /* Return the buffer that WINDOW is displaying.
500 WINDOW defaults to the selected window. */)
504 return decode_window (window
)->buffer
;
507 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
508 doc
: /* Return the number of lines in WINDOW (including its mode line).
509 WINDOW defaults to the selected window. */)
513 return decode_any_window (window
)->total_lines
;
516 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
517 doc
: /* Return the number of display columns in WINDOW.
518 This is the width that is usable columns available for text in WINDOW.
519 If you want to find out how many columns WINDOW takes up,
520 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
524 return make_number (window_box_text_cols (decode_any_window (window
)));
527 DEFUN ("window-full-width-p", Fwindow_full_width_p
, Swindow_full_width_p
, 0, 1, 0,
528 doc
: /* Return t if WINDOW is as wide as its frame.
529 WINDOW defaults to the selected window. */)
533 return WINDOW_FULL_WIDTH_P (decode_any_window (window
)) ? Qt
: Qnil
;
536 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
537 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
538 WINDOW defaults to the selected window. */)
542 return decode_window (window
)->hscroll
;
545 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
546 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
547 Return NCOL. NCOL should be zero or positive.
549 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
550 window so that the location of point moves off-window. */)
552 Lisp_Object window
, ncol
;
554 struct window
*w
= decode_window (window
);
558 hscroll
= max (0, XINT (ncol
));
560 /* Prevent redisplay shortcuts when changing the hscroll. */
561 if (XINT (w
->hscroll
) != hscroll
)
562 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
564 w
->hscroll
= make_number (hscroll
);
568 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
569 Swindow_redisplay_end_trigger
, 0, 1, 0,
570 doc
: /* Return WINDOW's redisplay end trigger value.
571 WINDOW defaults to the selected window.
572 See `set-window-redisplay-end-trigger' for more information. */)
576 return decode_window (window
)->redisplay_end_trigger
;
579 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
580 Sset_window_redisplay_end_trigger
, 2, 2, 0,
581 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
582 VALUE should be a buffer position (typically a marker) or nil.
583 If it is a buffer position, then if redisplay in WINDOW reaches a position
584 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
585 with two arguments: WINDOW, and the end trigger value.
586 Afterwards the end-trigger value is reset to nil. */)
588 register Lisp_Object window
, value
;
590 register struct window
*w
;
592 w
= decode_window (window
);
593 w
->redisplay_end_trigger
= value
;
597 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
598 doc
: /* Return a list of the edge coordinates of WINDOW.
599 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
600 RIGHT is one more than the rightmost column occupied by WINDOW,
601 and BOTTOM is one more than the bottommost row occupied by WINDOW.
602 The edges include the space used by the window's scroll bar,
603 display margins, fringes, header line, and mode line, if it has them.
604 To get the edges of the actual text area, use `window-inside-edges'. */)
608 register struct window
*w
= decode_any_window (window
);
610 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
611 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
612 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
613 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
617 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
618 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
619 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
620 RIGHT is one more than the rightmost x position occupied by WINDOW,
621 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
622 The pixel edges include the space used by the window's scroll bar,
623 display margins, fringes, header line, and mode line, if it has them.
624 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
628 register struct window
*w
= decode_any_window (window
);
630 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
631 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
632 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
633 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
637 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
638 doc
: /* Return a list of the edge coordinates of WINDOW.
639 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
640 RIGHT is one more than the rightmost column used by text in WINDOW,
641 and BOTTOM is one more than the bottommost row used by text in WINDOW.
642 The inside edges do not include the space used by the window's scroll bar,
643 display margins, fringes, header line, and/or mode line. */)
647 register struct window
*w
= decode_any_window (window
);
649 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
650 + WINDOW_LEFT_MARGIN_COLS (w
)
651 + WINDOW_LEFT_FRINGE_COLS (w
)),
652 make_number (WINDOW_TOP_EDGE_LINE (w
)
653 + WINDOW_HEADER_LINE_LINES (w
)),
654 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
655 - WINDOW_RIGHT_MARGIN_COLS (w
)
656 - WINDOW_RIGHT_FRINGE_COLS (w
)),
657 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
658 - WINDOW_MODE_LINE_LINES (w
)));
661 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
662 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
663 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
664 RIGHT is one more than the rightmost x position used by text in WINDOW,
665 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
666 The inside edges do not include the space used by the window's scroll bar,
667 display margins, fringes, header line, and/or mode line. */)
671 register struct window
*w
= decode_any_window (window
);
673 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
674 + WINDOW_LEFT_MARGIN_WIDTH (w
)
675 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
676 make_number (WINDOW_TOP_EDGE_Y (w
)
677 + WINDOW_HEADER_LINE_HEIGHT (w
)),
678 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
679 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
680 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
681 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
682 - WINDOW_MODE_LINE_HEIGHT (w
)));
685 /* Test if the character at column *X, row *Y is within window W.
686 If it is not, return ON_NOTHING;
687 if it is in the window's text area,
688 set *x and *y to its location relative to the upper left corner
691 if it is on the window's modeline, return ON_MODE_LINE;
692 if it is on the border between the window and its right sibling,
693 return ON_VERTICAL_BORDER.
694 if it is on a scroll bar,
695 return ON_SCROLL_BAR.
696 if it is on the window's top line, return ON_HEADER_LINE;
697 if it is in left or right fringe of the window,
698 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
699 to window-relative coordinates;
700 if it is in the marginal area to the left/right of the window,
701 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
702 to window-relative coordinates.
704 X and Y are frame relative pixel coordinates. */
706 static enum window_part
707 coordinates_in_window (w
, x
, y
)
708 register struct window
*w
;
711 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
712 int left_x
, right_x
, top_y
, bottom_y
;
713 enum window_part part
;
714 int ux
= FRAME_COLUMN_WIDTH (f
);
715 int x0
= WINDOW_LEFT_EDGE_X (w
);
716 int x1
= WINDOW_RIGHT_EDGE_X (w
);
717 /* The width of the area where the vertical line can be dragged.
718 (Between mode lines for instance. */
719 int grabbable_width
= ux
;
720 int lmargin_width
, rmargin_width
, text_left
, text_right
;
722 /* In what's below, we subtract 1 when computing right_x because we
723 want the rightmost pixel, which is given by left_pixel+width-1. */
724 if (w
->pseudo_window_p
)
727 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
728 top_y
= WINDOW_TOP_EDGE_Y (w
);
729 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
733 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
734 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
735 top_y
= WINDOW_TOP_EDGE_Y (w
);
736 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
739 /* Outside any interesting row? */
740 if (*y
< top_y
|| *y
>= bottom_y
)
743 /* On the mode line or header line? If it's near the start of
744 the mode or header line of window that's has a horizontal
745 sibling, say it's on the vertical line. That's to be able
746 to resize windows horizontally in case we're using toolkit
749 if (WINDOW_WANTS_MODELINE_P (w
)
750 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
754 header_vertical_border_check
:
755 /* We're somewhere on the mode line. We consider the place
756 between mode lines of horizontally adjacent mode lines
757 as the vertical border. If scroll bars on the left,
758 return the right window. */
759 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
760 || WINDOW_RIGHTMOST_P (w
))
762 if (!WINDOW_LEFTMOST_P (w
) && eabs (*x
- x0
) < grabbable_width
)
764 /* Convert X and Y to window relative coordinates.
765 Vertical border is at the left edge of window. */
766 *x
= max (0, *x
- x0
);
768 return ON_VERTICAL_BORDER
;
773 if (eabs (*x
- x1
) < grabbable_width
)
775 /* Convert X and Y to window relative coordinates.
776 Vertical border is at the right edge of window. */
777 *x
= min (x1
, *x
) - x0
;
779 return ON_VERTICAL_BORDER
;
783 if (*x
< x0
|| *x
>= x1
)
786 /* Convert X and Y to window relative coordinates.
787 Mode line starts at left edge of window. */
793 if (WINDOW_WANTS_HEADER_LINE_P (w
)
794 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
796 part
= ON_HEADER_LINE
;
797 goto header_vertical_border_check
;
800 if (*x
< x0
|| *x
>= x1
)
803 /* Outside any interesting column? */
804 if (*x
< left_x
|| *x
> right_x
)
807 return ON_SCROLL_BAR
;
810 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
811 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
813 text_left
= window_box_left (w
, TEXT_AREA
);
814 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
816 if (FRAME_WINDOW_P (f
))
818 if (!w
->pseudo_window_p
819 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
820 && !WINDOW_RIGHTMOST_P (w
)
821 && (eabs (*x
- right_x
) < grabbable_width
))
823 /* Convert X and Y to window relative coordinates.
824 Vertical border is at the right edge of window. */
825 *x
= min (right_x
, *x
) - left_x
;
827 return ON_VERTICAL_BORDER
;
832 /* Need to say "*x > right_x" rather than >=, since on character
833 terminals, the vertical line's x coordinate is right_x. */
834 if (!w
->pseudo_window_p
835 && !WINDOW_RIGHTMOST_P (w
)
836 && *x
> right_x
- ux
)
838 /* On the border on the right side of the window? Assume that
839 this area begins at RIGHT_X minus a canonical char width. */
840 *x
= min (right_x
, *x
) - left_x
;
842 return ON_VERTICAL_BORDER
;
848 if (lmargin_width
> 0
849 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
850 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
851 : (*x
< left_x
+ lmargin_width
)))
854 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
855 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
857 return ON_LEFT_MARGIN
;
860 /* Convert X and Y to window-relative pixel coordinates. */
863 return ON_LEFT_FRINGE
;
866 if (*x
>= text_right
)
868 if (rmargin_width
> 0
869 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
870 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
871 : (*x
>= right_x
- rmargin_width
)))
873 *x
-= right_x
- rmargin_width
;
874 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
875 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
877 return ON_RIGHT_MARGIN
;
880 /* Convert X and Y to window-relative pixel coordinates. */
881 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
883 return ON_RIGHT_FRINGE
;
886 /* Everything special ruled out - must be on text area */
893 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
894 Scoordinates_in_window_p
, 2, 2, 0,
895 doc
: /* Return non-nil if COORDINATES are in WINDOW.
896 COORDINATES is a cons of the form (X . Y), X and Y being distances
897 measured in characters from the upper-left corner of the frame.
898 \(0 . 0) denotes the character in the upper left corner of the
900 If COORDINATES are in the text portion of WINDOW,
901 the coordinates relative to the window are returned.
902 If they are in the mode line of WINDOW, `mode-line' is returned.
903 If they are in the top mode line of WINDOW, `header-line' is returned.
904 If they are in the left fringe of WINDOW, `left-fringe' is returned.
905 If they are in the right fringe of WINDOW, `right-fringe' is returned.
906 If they are on the border between WINDOW and its right sibling,
907 `vertical-line' is returned.
908 If they are in the windows's left or right marginal areas, `left-margin'\n\
909 or `right-margin' is returned. */)
910 (coordinates
, window
)
911 register Lisp_Object coordinates
, window
;
918 CHECK_WINDOW (window
);
919 w
= XWINDOW (window
);
920 f
= XFRAME (w
->frame
);
921 CHECK_CONS (coordinates
);
922 lx
= Fcar (coordinates
);
923 ly
= Fcdr (coordinates
);
924 CHECK_NUMBER_OR_FLOAT (lx
);
925 CHECK_NUMBER_OR_FLOAT (ly
);
926 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
927 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
929 switch (coordinates_in_window (w
, &x
, &y
))
935 /* X and Y are now window relative pixel coordinates. Convert
936 them to canonical char units before returning them. */
937 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
938 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
943 case ON_VERTICAL_BORDER
:
944 return Qvertical_line
;
952 case ON_RIGHT_FRINGE
:
953 return Qright_fringe
;
958 case ON_RIGHT_MARGIN
:
959 return Qright_margin
;
962 /* Historically we are supposed to return nil in this case. */
971 /* Callback for foreach_window, used in window_from_coordinates.
972 Check if window W contains coordinates specified by USER_DATA which
973 is actually a pointer to a struct check_window_data CW.
975 Check if window W contains coordinates *CW->x and *CW->y. If it
976 does, return W in *CW->window, as Lisp_Object, and return in
977 *CW->part the part of the window under coordinates *X,*Y. Return
978 zero from this function to stop iterating over windows. */
980 struct check_window_data
984 enum window_part
*part
;
988 check_window_containing (w
, user_data
)
992 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
993 enum window_part found
;
996 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
997 if (found
!= ON_NOTHING
)
1000 XSETWINDOW (*cw
->window
, w
);
1008 /* Find the window containing frame-relative pixel position X/Y and
1009 return it as a Lisp_Object.
1011 If X, Y is on one of the window's special `window_part' elements,
1012 set *PART to the id of that element, and return X and Y converted
1013 to window relative coordinates in WX and WY.
1015 If there is no window under X, Y return nil and leave *PART
1016 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1018 This function was previously implemented with a loop cycling over
1019 windows with Fnext_window, and starting with the frame's selected
1020 window. It turned out that this doesn't work with an
1021 implementation of next_window using Vwindow_list, because
1022 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1023 tree of F when this function is called asynchronously from
1024 note_mouse_highlight. The original loop didn't terminate in this
1028 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
1031 enum window_part
*part
;
1036 struct check_window_data cw
;
1037 enum window_part dummy
;
1043 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1044 foreach_window (f
, check_window_containing
, &cw
);
1046 /* If not found above, see if it's in the tool bar window, if a tool
1050 && WINDOWP (f
->tool_bar_window
)
1051 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1052 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1056 window
= f
->tool_bar_window
;
1065 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1066 doc
: /* Return window containing coordinates X and Y on FRAME.
1067 If omitted, FRAME defaults to the currently selected frame.
1068 The top left corner of the frame is considered to be row 0,
1071 Lisp_Object x
, y
, frame
;
1076 frame
= selected_frame
;
1077 CHECK_LIVE_FRAME (frame
);
1080 /* Check that arguments are integers or floats. */
1081 CHECK_NUMBER_OR_FLOAT (x
);
1082 CHECK_NUMBER_OR_FLOAT (y
);
1084 return window_from_coordinates (f
,
1085 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1086 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1087 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1088 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1092 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1093 doc
: /* Return current value of point in WINDOW.
1094 WINDOW defaults to the selected window.
1096 For a nonselected window, this is the value point would have
1097 if that window were selected.
1099 Note that, when WINDOW is the selected window and its buffer
1100 is also currently selected, the value returned is the same as (point).
1101 It would be more strictly correct to return the `top-level' value
1102 of point, outside of any save-excursion forms.
1103 But that is hard to define. */)
1107 register struct window
*w
= decode_window (window
);
1109 if (w
== XWINDOW (selected_window
)
1110 && current_buffer
== XBUFFER (w
->buffer
))
1112 return Fmarker_position (w
->pointm
);
1115 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1116 doc
: /* Return position at which display currently starts in WINDOW.
1117 WINDOW defaults to the selected window.
1118 This is updated by redisplay or by calling `set-window-start'. */)
1122 return Fmarker_position (decode_window (window
)->start
);
1125 /* This is text temporarily removed from the doc string below.
1127 This function returns nil if the position is not currently known.
1128 That happens when redisplay is preempted and doesn't finish.
1129 If in that case you want to compute where the end of the window would
1130 have been if redisplay had finished, do this:
1132 (goto-char (window-start window))
1133 (vertical-motion (1- (window-height window)) window)
1136 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1137 doc
: /* Return position at which display currently ends in WINDOW.
1138 WINDOW defaults to the selected window.
1139 This is updated by redisplay, when it runs to completion.
1140 Simply changing the buffer text or setting `window-start'
1141 does not update this value.
1142 Return nil if there is no recorded value. \(This can happen if the
1143 last redisplay of WINDOW was preempted, and did not finish.)
1144 If UPDATE is non-nil, compute the up-to-date position
1145 if it isn't already recorded. */)
1147 Lisp_Object window
, update
;
1150 struct window
*w
= decode_window (window
);
1158 #if 0 /* This change broke some things. We should make it later. */
1159 /* If we don't know the end position, return nil.
1160 The user can compute it with vertical-motion if he wants to.
1161 It would be nicer to do it automatically,
1162 but that's so slow that it would probably bother people. */
1163 if (NILP (w
->window_end_valid
))
1168 && ! (! NILP (w
->window_end_valid
)
1169 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1170 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1173 struct text_pos startp
;
1175 struct buffer
*old_buffer
= NULL
;
1177 /* Cannot use Fvertical_motion because that function doesn't
1178 cope with variable-height lines. */
1179 if (b
!= current_buffer
)
1181 old_buffer
= current_buffer
;
1182 set_buffer_internal (b
);
1185 /* In case W->start is out of the range, use something
1186 reasonable. This situation occurred when loading a file with
1187 `-l' containing a call to `rmail' with subsequent other
1188 commands. At the end, W->start happened to be BEG, while
1189 rmail had already narrowed the buffer. */
1190 if (XMARKER (w
->start
)->charpos
< BEGV
)
1191 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1192 else if (XMARKER (w
->start
)->charpos
> ZV
)
1193 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1195 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1197 start_display (&it
, w
, startp
);
1198 move_it_vertically (&it
, window_box_height (w
));
1199 if (it
.current_y
< it
.last_visible_y
)
1200 move_it_past_eol (&it
);
1201 value
= make_number (IT_CHARPOS (it
));
1204 set_buffer_internal (old_buffer
);
1207 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1212 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1213 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1216 Lisp_Object window
, pos
;
1218 register struct window
*w
= decode_window (window
);
1220 CHECK_NUMBER_COERCE_MARKER (pos
);
1221 if (w
== XWINDOW (selected_window
)
1222 && XBUFFER (w
->buffer
) == current_buffer
)
1225 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1227 /* We have to make sure that redisplay updates the window to show
1228 the new value of point. */
1229 if (!EQ (window
, selected_window
))
1230 ++windows_or_buffers_changed
;
1235 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1236 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1238 Optional third arg NOFORCE non-nil inhibits next redisplay
1239 from overriding motion of point in order to display at this exact start. */)
1240 (window
, pos
, noforce
)
1241 Lisp_Object window
, pos
, noforce
;
1243 register struct window
*w
= decode_window (window
);
1245 CHECK_NUMBER_COERCE_MARKER (pos
);
1246 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1247 /* this is not right, but much easier than doing what is right. */
1248 w
->start_at_line_beg
= Qnil
;
1250 w
->force_start
= Qt
;
1251 w
->update_mode_line
= Qt
;
1252 XSETFASTINT (w
->last_modified
, 0);
1253 XSETFASTINT (w
->last_overlay_modified
, 0);
1254 if (!EQ (window
, selected_window
))
1255 windows_or_buffers_changed
++;
1260 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1262 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1263 See also `set-window-dedicated-p'. */)
1267 return decode_window (window
)->dedicated
;
1270 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1271 Sset_window_dedicated_p
, 2, 2, 0,
1272 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1273 If it is dedicated, Emacs will not automatically change
1274 which buffer appears in it.
1275 The second argument is the new value for the dedication flag;
1276 non-nil means yes. */)
1278 Lisp_Object window
, arg
;
1280 register struct window
*w
= decode_window (window
);
1284 return w
->dedicated
;
1287 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1289 doc
: /* Return the parameters-alist of window WINDOW.
1290 It is a list of elements of the form (PARAMETER . VALUE).
1291 If WINDOW is omitted, return information on the currently selected window. */)
1295 return Fcopy_alist (decode_window (window
)->window_parameters
);
1298 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1300 doc
: /* Return WINDOW's value for parameter PARAMETER.
1301 If WINDOW is nil, describe the currently selected window. */)
1303 Lisp_Object window
, parameter
;
1307 result
= Fassq (parameter
, decode_window (window
)->window_parameters
);
1308 return CDR_SAFE (result
);
1312 DEFUN ("set-window-parameter", Fset_window_parameter
,
1313 Sset_window_parameter
, 3, 3, 0,
1314 doc
: /* Set window parameter PARAMETER to VALUE on WINDOW.
1315 If WINDOW is nil, use the currently selected window.
1317 (window
, parameter
, value
)
1318 Lisp_Object window
, parameter
, value
;
1320 register struct window
*w
= decode_window (window
);
1321 Lisp_Object old_alist_elt
;
1323 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1324 if (EQ (old_alist_elt
, Qnil
))
1325 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1327 Fsetcdr (old_alist_elt
, value
);
1332 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1334 doc
: /* Return the display-table that WINDOW is using.
1335 WINDOW defaults to the selected window. */)
1339 return decode_window (window
)->display_table
;
1342 /* Get the display table for use on window W. This is either W's
1343 display table or W's buffer's display table. Ignore the specified
1344 tables if they are not valid; if no valid table is specified,
1347 struct Lisp_Char_Table
*
1348 window_display_table (w
)
1351 struct Lisp_Char_Table
*dp
= NULL
;
1353 if (DISP_TABLE_P (w
->display_table
))
1354 dp
= XCHAR_TABLE (w
->display_table
);
1355 else if (BUFFERP (w
->buffer
))
1357 struct buffer
*b
= XBUFFER (w
->buffer
);
1359 if (DISP_TABLE_P (b
->display_table
))
1360 dp
= XCHAR_TABLE (b
->display_table
);
1361 else if (DISP_TABLE_P (Vstandard_display_table
))
1362 dp
= XCHAR_TABLE (Vstandard_display_table
);
1368 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1369 doc
: /* Set WINDOW's display-table to TABLE. */)
1371 register Lisp_Object window
, table
;
1373 register struct window
*w
;
1375 w
= decode_window (window
);
1376 w
->display_table
= table
;
1380 /* Record info on buffer window w is displaying
1381 when it is about to cease to display that buffer. */
1384 register struct window
*w
;
1391 if (b
!= XMARKER (w
->pointm
)->buffer
)
1395 if (w
== XWINDOW (selected_window
)
1396 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1397 /* Do this except when the selected window's buffer
1398 is being removed from some other window. */
1400 /* last_window_start records the start position that this buffer
1401 had in the last window to be disconnected from it.
1402 Now that this statement is unconditional,
1403 it is possible for the buffer to be displayed in the
1404 selected window, while last_window_start reflects another
1405 window which was recently showing the same buffer.
1406 Some people might say that might be a good thing. Let's see. */
1407 b
->last_window_start
= marker_position (w
->start
);
1409 /* Point in the selected window's buffer
1410 is actually stored in that buffer, and the window's pointm isn't used.
1411 So don't clobber point in that buffer. */
1412 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1413 /* This line helps to fix Horsley's testbug.el bug. */
1414 && !(WINDOWP (b
->last_selected_window
)
1415 && w
!= XWINDOW (b
->last_selected_window
)
1416 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1417 temp_set_point_both (b
,
1418 clip_to_bounds (BUF_BEGV (b
),
1419 XMARKER (w
->pointm
)->charpos
,
1421 clip_to_bounds (BUF_BEGV_BYTE (b
),
1422 marker_byte_position (w
->pointm
),
1425 if (WINDOWP (b
->last_selected_window
)
1426 && w
== XWINDOW (b
->last_selected_window
))
1427 b
->last_selected_window
= Qnil
;
1430 /* Put replacement into the window structure in place of old. */
1432 replace_window (old
, replacement
)
1433 Lisp_Object old
, replacement
;
1435 register Lisp_Object tem
;
1436 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1438 /* If OLD is its frame's root_window, then replacement is the new
1439 root_window for that frame. */
1441 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1442 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1444 p
->left_col
= o
->left_col
;
1445 p
->top_line
= o
->top_line
;
1446 p
->total_cols
= o
->total_cols
;
1447 p
->total_lines
= o
->total_lines
;
1448 p
->desired_matrix
= p
->current_matrix
= 0;
1450 bzero (&p
->cursor
, sizeof (p
->cursor
));
1451 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1452 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1453 p
->phys_cursor_type
= -1;
1454 p
->phys_cursor_width
= -1;
1455 p
->must_be_updated_p
= 0;
1456 p
->pseudo_window_p
= 0;
1457 XSETFASTINT (p
->window_end_vpos
, 0);
1458 XSETFASTINT (p
->window_end_pos
, 0);
1459 p
->window_end_valid
= Qnil
;
1460 p
->frozen_window_start_p
= 0;
1461 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1463 p
->next
= tem
= o
->next
;
1465 XWINDOW (tem
)->prev
= replacement
;
1467 p
->prev
= tem
= o
->prev
;
1469 XWINDOW (tem
)->next
= replacement
;
1471 p
->parent
= tem
= o
->parent
;
1474 if (EQ (XWINDOW (tem
)->vchild
, old
))
1475 XWINDOW (tem
)->vchild
= replacement
;
1476 if (EQ (XWINDOW (tem
)->hchild
, old
))
1477 XWINDOW (tem
)->hchild
= replacement
;
1480 /*** Here, if replacement is a vertical combination
1481 and so is its new parent, we should make replacement's
1482 children be children of that parent instead. ***/
1485 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1486 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1488 register Lisp_Object window
;
1492 window
= selected_window
;
1493 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1494 delete_window (window
);
1496 run_window_configuration_change_hook (f
);
1502 delete_window (window
)
1503 register Lisp_Object window
;
1505 register Lisp_Object tem
, parent
, sib
;
1506 register struct window
*p
;
1507 register struct window
*par
;
1510 /* Because this function is called by other C code on non-leaf
1511 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1512 so we can't decode_window here. */
1513 CHECK_WINDOW (window
);
1514 p
= XWINDOW (window
);
1516 /* It's a no-op to delete an already-deleted window. */
1517 if (NILP (p
->buffer
)
1519 && NILP (p
->vchild
))
1524 error ("Attempt to delete minibuffer or sole ordinary window");
1525 par
= XWINDOW (parent
);
1527 windows_or_buffers_changed
++;
1528 Vwindow_list
= Qnil
;
1529 f
= XFRAME (WINDOW_FRAME (p
));
1530 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1532 /* Are we trying to delete any frame's selected window? */
1534 Lisp_Object swindow
, pwindow
;
1536 /* See if the frame's selected window is either WINDOW
1537 or any subwindow of it, by finding all that window's parents
1538 and comparing each one with WINDOW. */
1539 swindow
= FRAME_SELECTED_WINDOW (f
);
1544 while (!NILP (pwindow
))
1546 if (EQ (window
, pwindow
))
1548 pwindow
= XWINDOW (pwindow
)->parent
;
1551 /* If the window being deleted is not a parent of SWINDOW,
1552 then SWINDOW is ok as the new selected window. */
1553 if (!EQ (window
, pwindow
))
1555 /* Otherwise, try another window for SWINDOW. */
1556 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);
1558 /* If we get back to the frame's selected window,
1559 it means there was no acceptable alternative,
1560 so we cannot delete. */
1561 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1562 error ("Cannot delete window");
1565 /* If we need to change SWINDOW, do it. */
1566 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1568 /* If we're about to delete the selected window on the
1569 selected frame, then we should use Fselect_window to select
1570 the new window. On the other hand, if we're about to
1571 delete the selected window on any other frame, we shouldn't do
1572 anything but set the frame's selected_window slot. */
1573 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1574 Fselect_window (swindow
, Qnil
);
1576 FRAME_SELECTED_WINDOW (f
) = swindow
;
1580 /* Now we know we can delete this one. */
1581 window_deletion_count
++;
1584 /* tem is null for dummy parent windows
1585 (which have inferiors but not any contents themselves) */
1589 unchain_marker (XMARKER (p
->pointm
));
1590 unchain_marker (XMARKER (p
->start
));
1593 /* Free window glyph matrices. It is sure that they are allocated
1594 again when ADJUST_GLYPHS is called. Block input so that expose
1595 events and other events that access glyph matrices are not
1596 processed while we are changing them. */
1598 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1602 XWINDOW (tem
)->prev
= p
->prev
;
1606 XWINDOW (tem
)->next
= p
->next
;
1608 if (EQ (window
, par
->hchild
))
1609 par
->hchild
= p
->next
;
1610 if (EQ (window
, par
->vchild
))
1611 par
->vchild
= p
->next
;
1613 /* Find one of our siblings to give our space to. */
1617 /* If p gives its space to its next sibling, that sibling needs
1618 to have its top/left side pulled back to where p's is.
1619 set_window_{height,width} will re-position the sibling's
1622 XWINDOW (sib
)->top_line
= p
->top_line
;
1623 XWINDOW (sib
)->left_col
= p
->left_col
;
1626 /* Stretch that sibling. */
1627 if (!NILP (par
->vchild
))
1628 set_window_height (sib
,
1629 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1631 if (!NILP (par
->hchild
))
1632 set_window_width (sib
,
1633 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1636 /* If parent now has only one child,
1637 put the child into the parent's place. */
1641 if (NILP (XWINDOW (tem
)->next
)) {
1642 replace_window (parent
, tem
);
1643 par
= XWINDOW (tem
);
1646 /* Since we may be deleting combination windows, we must make sure that
1647 not only p but all its children have been marked as deleted. */
1648 if (! NILP (p
->hchild
))
1649 delete_all_subwindows (XWINDOW (p
->hchild
));
1650 else if (! NILP (p
->vchild
))
1651 delete_all_subwindows (XWINDOW (p
->vchild
));
1653 /* Mark this window as deleted. */
1654 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1656 if (! NILP (par
->parent
))
1657 par
= XWINDOW (par
->parent
);
1659 /* Check if we have a v/hchild with a v/hchild. In that case remove
1662 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1664 p
= XWINDOW (par
->vchild
);
1665 par
->vchild
= p
->vchild
;
1668 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1670 p
= XWINDOW (par
->hchild
);
1671 par
->hchild
= p
->hchild
;
1679 while (! NILP (tem
)) {
1680 XWINDOW (tem
)->parent
= p
->parent
;
1681 if (NILP (XWINDOW (tem
)->next
))
1683 tem
= XWINDOW (tem
)->next
;
1686 /* The next of the v/hchild we are removing is now the next of the
1687 last child for the v/hchild:
1688 Before v/hchild -> v/hchild -> next1 -> next2
1691 After: v/hchild -> next1 -> next2 -> next3
1693 XWINDOW (tem
)->next
= p
->next
;
1694 if (! NILP (p
->next
))
1695 XWINDOW (p
->next
)->prev
= tem
;
1697 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1701 /* Adjust glyph matrices. */
1708 /***********************************************************************
1710 ***********************************************************************/
1712 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1713 pointer. This is a callback function for foreach_window, used in
1714 function window_list. */
1717 add_window_to_list (w
, user_data
)
1721 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1723 XSETWINDOW (window
, w
);
1724 *list
= Fcons (window
, *list
);
1729 /* Return a list of all windows, for use by next_window. If
1730 Vwindow_list is a list, return that list. Otherwise, build a new
1731 list, cache it in Vwindow_list, and return that. */
1736 if (!CONSP (Vwindow_list
))
1740 Vwindow_list
= Qnil
;
1741 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1743 Lisp_Object args
[2];
1745 /* We are visiting windows in canonical order, and add
1746 new windows at the front of args[1], which means we
1747 have to reverse this list at the end. */
1749 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1750 args
[0] = Vwindow_list
;
1751 args
[1] = Fnreverse (args
[1]);
1752 Vwindow_list
= Fnconc (2, args
);
1756 return Vwindow_list
;
1760 /* Value is non-zero if WINDOW satisfies the constraints given by
1761 OWINDOW, MINIBUF and ALL_FRAMES.
1763 MINIBUF t means WINDOW may be minibuffer windows.
1764 `lambda' means WINDOW may not be a minibuffer window.
1765 a window means a specific minibuffer window
1767 ALL_FRAMES t means search all frames,
1768 nil means search just current frame,
1769 `visible' means search just visible frames,
1770 0 means search visible and iconified frames,
1771 a window means search the frame that window belongs to,
1772 a frame means consider windows on that frame, only. */
1775 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1776 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1778 struct window
*w
= XWINDOW (window
);
1779 struct frame
*f
= XFRAME (w
->frame
);
1780 int candidate_p
= 1;
1782 if (!BUFFERP (w
->buffer
))
1784 else if (MINI_WINDOW_P (w
)
1785 && (EQ (minibuf
, Qlambda
)
1786 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1788 /* If MINIBUF is `lambda' don't consider any mini-windows.
1789 If it is a window, consider only that one. */
1792 else if (EQ (all_frames
, Qt
))
1794 else if (NILP (all_frames
))
1796 xassert (WINDOWP (owindow
));
1797 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1799 else if (EQ (all_frames
, Qvisible
))
1801 FRAME_SAMPLE_VISIBILITY (f
);
1802 candidate_p
= FRAME_VISIBLE_P (f
)
1803 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1804 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1807 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1809 FRAME_SAMPLE_VISIBILITY (f
);
1810 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
1811 #ifdef HAVE_X_WINDOWS
1812 /* Yuck!! If we've just created the frame and the
1813 window-manager requested the user to place it
1814 manually, the window may still not be considered
1815 `visible'. I'd argue it should be at least
1816 something like `iconified', but don't know how to do
1818 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
1819 && !f
->output_data
.x
->has_been_visible
)
1822 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1823 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1825 else if (WINDOWP (all_frames
))
1826 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1827 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1828 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1829 else if (FRAMEP (all_frames
))
1830 candidate_p
= EQ (all_frames
, w
->frame
);
1836 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1837 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1841 decode_next_window_args (window
, minibuf
, all_frames
)
1842 Lisp_Object
*window
, *minibuf
, *all_frames
;
1845 *window
= selected_window
;
1847 CHECK_LIVE_WINDOW (*window
);
1849 /* MINIBUF nil may or may not include minibuffers. Decide if it
1851 if (NILP (*minibuf
))
1852 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1853 else if (!EQ (*minibuf
, Qt
))
1856 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1857 => count none of them, or a specific minibuffer window (the
1858 active one) to count. */
1860 /* ALL_FRAMES nil doesn't specify which frames to include. */
1861 if (NILP (*all_frames
))
1862 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1863 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1865 else if (EQ (*all_frames
, Qvisible
))
1867 else if (EQ (*all_frames
, make_number (0)))
1869 else if (FRAMEP (*all_frames
))
1871 else if (!EQ (*all_frames
, Qt
))
1874 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1875 search just current frame, `visible' meaning search just visible
1876 frames, 0 meaning search visible and iconified frames, or a
1877 window, meaning search the frame that window belongs to, or a
1878 frame, meaning consider windows on that frame, only. */
1882 /* Return the next or previous window of WINDOW in canonical ordering
1883 of windows. NEXT_P non-zero means return the next window. See the
1884 documentation string of next-window for the meaning of MINIBUF and
1888 next_window (window
, minibuf
, all_frames
, next_p
)
1889 Lisp_Object window
, minibuf
, all_frames
;
1892 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1894 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1895 return the first window on the frame. */
1896 if (FRAMEP (all_frames
)
1897 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1898 return Fframe_first_window (all_frames
);
1904 /* Find WINDOW in the list of all windows. */
1905 list
= Fmemq (window
, window_list ());
1907 /* Scan forward from WINDOW to the end of the window list. */
1909 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1910 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1913 /* Scan from the start of the window list up to WINDOW. */
1915 for (list
= Vwindow_list
;
1916 CONSP (list
) && !EQ (XCAR (list
), window
);
1918 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1922 window
= XCAR (list
);
1926 Lisp_Object candidate
, list
;
1928 /* Scan through the list of windows for candidates. If there are
1929 candidate windows in front of WINDOW, the last one of these
1930 is the one we want. If there are candidates following WINDOW
1931 in the list, again the last one of these is the one we want. */
1933 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1935 if (EQ (XCAR (list
), window
))
1937 if (WINDOWP (candidate
))
1940 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1942 candidate
= XCAR (list
);
1945 if (WINDOWP (candidate
))
1953 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1954 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1955 If omitted, WINDOW defaults to the selected window.
1957 Optional second arg MINIBUF t means count the minibuffer window even
1958 if not active. MINIBUF nil or omitted means count the minibuffer iff
1959 it is active. MINIBUF neither t nor nil means not to count the
1960 minibuffer even if it is active.
1962 Several frames may share a single minibuffer; if the minibuffer
1963 counts, all windows on all frames that share that minibuffer count
1964 too. Therefore, `next-window' can be used to iterate through the
1965 set of windows even when the minibuffer is on another frame. If the
1966 minibuffer does not count, only windows from WINDOW's frame count.
1968 Optional third arg ALL-FRAMES t means include windows on all frames.
1969 ALL-FRAMES nil or omitted means cycle within the frames as specified
1970 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1971 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1972 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1973 Anything else means restrict to WINDOW's frame.
1975 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1976 `next-window' to iterate through the entire cycle of acceptable
1977 windows, eventually ending up back at the window you started with.
1978 `previous-window' traverses the same cycle, in the reverse order. */)
1979 (window
, minibuf
, all_frames
)
1980 Lisp_Object window
, minibuf
, all_frames
;
1982 return next_window (window
, minibuf
, all_frames
, 1);
1986 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1987 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1988 If omitted, WINDOW defaults to the selected window.
1990 Optional second arg MINIBUF t means count the minibuffer window even
1991 if not active. MINIBUF nil or omitted means count the minibuffer iff
1992 it is active. MINIBUF neither t nor nil means not to count the
1993 minibuffer even if it is active.
1995 Several frames may share a single minibuffer; if the minibuffer
1996 counts, all windows on all frames that share that minibuffer count
1997 too. Therefore, `previous-window' can be used to iterate through
1998 the set of windows even when the minibuffer is on another frame. If
1999 the minibuffer does not count, only windows from WINDOW's frame count
2001 Optional third arg ALL-FRAMES t means include windows on all frames.
2002 ALL-FRAMES nil or omitted means cycle within the frames as specified
2003 above. ALL-FRAMES = `visible' means include windows on all visible frames.
2004 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
2005 If ALL-FRAMES is a frame, restrict search to windows on that frame.
2006 Anything else means restrict to WINDOW's frame.
2008 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2009 `previous-window' to iterate through the entire cycle of acceptable
2010 windows, eventually ending up back at the window you started with.
2011 `next-window' traverses the same cycle, in the reverse order. */)
2012 (window
, minibuf
, all_frames
)
2013 Lisp_Object window
, minibuf
, all_frames
;
2015 return next_window (window
, minibuf
, all_frames
, 0);
2019 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
2020 doc
: /* Select the ARG'th different window on this frame.
2021 All windows on current frame are arranged in a cyclic order.
2022 This command selects the window ARG steps away in that order.
2023 A negative ARG moves in the opposite order. The optional second
2024 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
2026 Lisp_Object arg
, all_frames
;
2032 window
= selected_window
;
2034 for (i
= XINT (arg
); i
> 0; --i
)
2035 window
= Fnext_window (window
, Qnil
, all_frames
);
2037 window
= Fprevious_window (window
, Qnil
, all_frames
);
2039 Fselect_window (window
, Qnil
);
2044 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2045 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2046 FRAME nil or omitted means use the selected frame.
2047 WINDOW nil or omitted means use the selected window.
2048 MINIBUF t means include the minibuffer window, even if it isn't active.
2049 MINIBUF nil or omitted means include the minibuffer window only
2051 MINIBUF neither nil nor t means never include the minibuffer window. */)
2052 (frame
, minibuf
, window
)
2053 Lisp_Object frame
, minibuf
, window
;
2056 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2057 CHECK_WINDOW (window
);
2059 frame
= selected_frame
;
2061 if (!EQ (frame
, XWINDOW (window
)->frame
))
2062 error ("Window is on a different frame");
2064 return window_list_1 (window
, minibuf
, frame
);
2068 /* Return a list of windows in canonical ordering. Arguments are like
2069 for `next-window'. */
2072 window_list_1 (window
, minibuf
, all_frames
)
2073 Lisp_Object window
, minibuf
, all_frames
;
2075 Lisp_Object tail
, list
, rest
;
2077 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2080 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2081 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2082 list
= Fcons (XCAR (tail
), list
);
2084 /* Rotate the list to start with WINDOW. */
2085 list
= Fnreverse (list
);
2086 rest
= Fmemq (window
, list
);
2087 if (!NILP (rest
) && !EQ (rest
, list
))
2089 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2091 XSETCDR (tail
, Qnil
);
2092 list
= nconc2 (rest
, list
);
2099 /* Look at all windows, performing an operation specified by TYPE
2101 If FRAMES is Qt, look at all frames;
2102 Qnil, look at just the selected frame;
2103 Qvisible, look at visible frames;
2104 a frame, just look at windows on that frame.
2105 If MINI is non-zero, perform the operation on minibuffer windows too. */
2110 GET_BUFFER_WINDOW
, /* Arg is buffer */
2111 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2112 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2113 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2115 UNSHOW_BUFFER
, /* Arg is buffer */
2116 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2121 window_loop (type
, obj
, mini
, frames
)
2122 enum window_loop type
;
2123 Lisp_Object obj
, frames
;
2126 Lisp_Object window
, windows
, best_window
, frame_arg
;
2128 struct gcpro gcpro1
;
2130 /* If we're only looping through windows on a particular frame,
2131 frame points to that frame. If we're looping through windows
2132 on all frames, frame is 0. */
2133 if (FRAMEP (frames
))
2134 f
= XFRAME (frames
);
2135 else if (NILP (frames
))
2136 f
= SELECTED_FRAME ();
2141 frame_arg
= Qlambda
;
2142 else if (EQ (frames
, make_number (0)))
2144 else if (EQ (frames
, Qvisible
))
2149 /* frame_arg is Qlambda to stick to one frame,
2150 Qvisible to consider all visible frames,
2153 /* Pick a window to start with. */
2157 window
= FRAME_SELECTED_WINDOW (f
);
2159 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2161 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2165 for (; CONSP (windows
); windows
= XCDR (windows
))
2169 window
= XCAR (windows
);
2170 w
= XWINDOW (window
);
2172 /* Note that we do not pay attention here to whether the frame
2173 is visible, since Fwindow_list skips non-visible frames if
2174 that is desired, under the control of frame_arg. */
2175 if (!MINI_WINDOW_P (w
)
2176 /* For UNSHOW_BUFFER, we must always consider all windows. */
2177 || type
== UNSHOW_BUFFER
2178 || (mini
&& minibuf_level
> 0))
2181 case GET_BUFFER_WINDOW
:
2182 if (EQ (w
->buffer
, obj
)
2183 /* Don't find any minibuffer window
2184 except the one that is currently in use. */
2185 && (MINI_WINDOW_P (w
)
2186 ? EQ (window
, minibuf_window
)
2189 if (NILP (best_window
))
2190 best_window
= window
;
2191 else if (EQ (window
, selected_window
))
2192 /* Prefer to return selected-window. */
2193 RETURN_UNGCPRO (window
);
2194 else if (EQ (Fwindow_frame (window
), selected_frame
))
2195 /* Prefer windows on the current frame. */
2196 best_window
= window
;
2200 case GET_LRU_WINDOW
:
2201 /* `obj' is an integer encoding a bitvector.
2202 `obj & 1' means consider only full-width windows.
2203 `obj & 2' means consider also dedicated windows. */
2204 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2205 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2206 /* Minibuffer windows are always ignored. */
2207 || MINI_WINDOW_P (w
))
2209 if (NILP (best_window
)
2210 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2211 > XFASTINT (w
->use_time
)))
2212 best_window
= window
;
2215 case DELETE_OTHER_WINDOWS
:
2216 if (!EQ (window
, obj
))
2217 Fdelete_window (window
);
2220 case DELETE_BUFFER_WINDOWS
:
2221 if (EQ (w
->buffer
, obj
))
2223 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2225 /* If this window is dedicated, and in a frame of its own,
2227 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2228 && !NILP (w
->dedicated
)
2229 && other_visible_frames (f
))
2231 /* Skip the other windows on this frame.
2232 There might be one, the minibuffer! */
2233 while (CONSP (XCDR (windows
))
2234 && EQ (XWINDOW (XCAR (windows
))->frame
,
2235 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2236 windows
= XCDR (windows
);
2238 /* Now we can safely delete the frame. */
2239 Fdelete_frame (w
->frame
, Qnil
);
2241 else if (NILP (w
->parent
))
2243 /* If we're deleting the buffer displayed in the
2244 only window on the frame, find a new buffer to
2247 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2248 Fset_window_buffer (window
, buffer
, Qnil
);
2249 if (EQ (window
, selected_window
))
2250 Fset_buffer (w
->buffer
);
2253 Fdelete_window (window
);
2257 case GET_LARGEST_WINDOW
:
2258 { /* nil `obj' means to ignore dedicated windows. */
2259 /* Ignore dedicated windows and minibuffers. */
2260 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2263 if (NILP (best_window
))
2264 best_window
= window
;
2267 struct window
*b
= XWINDOW (best_window
);
2268 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2269 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2270 best_window
= window
;
2276 if (EQ (w
->buffer
, obj
))
2279 struct frame
*f
= XFRAME (w
->frame
);
2281 /* Find another buffer to show in this window. */
2282 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2284 /* If this window is dedicated, and in a frame of its own,
2286 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2287 && !NILP (w
->dedicated
)
2288 && other_visible_frames (f
))
2290 /* Skip the other windows on this frame.
2291 There might be one, the minibuffer! */
2292 while (CONSP (XCDR (windows
))
2293 && EQ (XWINDOW (XCAR (windows
))->frame
,
2294 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2295 windows
= XCDR (windows
);
2297 /* Now we can safely delete the frame. */
2298 Fdelete_frame (w
->frame
, Qnil
);
2300 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2303 XSETWINDOW (window
, w
);
2304 /* If this window is dedicated and not the only window
2305 in its frame, then kill it. */
2306 Fdelete_window (window
);
2310 /* Otherwise show a different buffer in the window. */
2311 w
->dedicated
= Qnil
;
2312 Fset_window_buffer (window
, buffer
, Qnil
);
2313 if (EQ (window
, selected_window
))
2314 Fset_buffer (w
->buffer
);
2319 case REDISPLAY_BUFFER_WINDOWS
:
2320 if (EQ (w
->buffer
, obj
))
2322 mark_window_display_accurate (window
, 0);
2323 w
->update_mode_line
= Qt
;
2324 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2325 ++update_mode_lines
;
2326 best_window
= window
;
2330 /* Check for a window that has a killed buffer. */
2331 case CHECK_ALL_WINDOWS
:
2332 if (! NILP (w
->buffer
)
2333 && NILP (XBUFFER (w
->buffer
)->name
))
2337 case WINDOW_LOOP_UNUSED
:
2346 /* Used for debugging. Abort if any window has a dead buffer. */
2349 check_all_windows ()
2351 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2354 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2355 doc
: /* Return the window least recently selected or used for display.
2356 \(LRU means Least Recently Used.)
2358 Return a full-width window if possible.
2359 A minibuffer window is never a candidate.
2360 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2361 so if all windows are dedicated, the value is nil.
2362 If optional argument FRAME is `visible', search all visible frames.
2363 If FRAME is 0, search all visible and iconified frames.
2364 If FRAME is t, search all frames.
2365 If FRAME is nil, search only the selected frame.
2366 If FRAME is a frame, search only that frame. */)
2368 Lisp_Object frame
, dedicated
;
2370 register Lisp_Object w
;
2371 /* First try for a window that is full-width */
2372 w
= window_loop (GET_LRU_WINDOW
,
2373 NILP (dedicated
) ? make_number (1) : make_number (3),
2375 if (!NILP (w
) && !EQ (w
, selected_window
))
2377 /* If none of them, try the rest */
2378 return window_loop (GET_LRU_WINDOW
,
2379 NILP (dedicated
) ? make_number (0) : make_number (2),
2383 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2384 doc
: /* Return the largest window in area.
2385 A minibuffer window is never a candidate.
2386 A dedicated window is never a candidate unless DEDICATED is non-nil,
2387 so if all windows are dedicated, the value is nil.
2388 If optional argument FRAME is `visible', search all visible frames.
2389 If FRAME is 0, search all visible and iconified frames.
2390 If FRAME is t, search all frames.
2391 If FRAME is nil, search only the selected frame.
2392 If FRAME is a frame, search only that frame. */)
2394 Lisp_Object frame
, dedicated
;
2396 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2400 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2401 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2402 BUFFER can be a buffer or a buffer name.
2403 If optional argument FRAME is `visible', search all visible frames.
2404 If optional argument FRAME is 0, search all visible and iconified frames.
2405 If FRAME is t, search all frames.
2406 If FRAME is nil, search only the selected frame.
2407 If FRAME is a frame, search only that frame. */)
2409 Lisp_Object buffer
, frame
;
2411 buffer
= Fget_buffer (buffer
);
2412 if (BUFFERP (buffer
))
2413 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2418 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2420 doc
: /* Make WINDOW (or the selected window) fill its frame.
2421 Only the frame WINDOW is on is affected.
2422 This function tries to reduce display jumps
2423 by keeping the text previously visible in WINDOW
2424 in the same place on the frame. Doing this depends on
2425 the value of (window-start WINDOW), so if calling this function
2426 in a program gives strange scrolling, make sure the window-start
2427 value is reasonable when this function is called. */)
2436 window
= selected_window
;
2438 CHECK_LIVE_WINDOW (window
);
2439 w
= XWINDOW (window
);
2441 startpos
= marker_position (w
->start
);
2442 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2444 if (MINI_WINDOW_P (w
) && top
> 0)
2445 error ("Can't expand minibuffer to full frame");
2447 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2449 /* Try to minimize scrolling, by setting the window start to the point
2450 will cause the text at the old window start to be at the same place
2451 on the frame. But don't try to do this if the window start is
2452 outside the visible portion (as might happen when the display is
2453 not current, due to typeahead). */
2454 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2456 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2457 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2459 struct position pos
;
2460 struct buffer
*obuf
= current_buffer
;
2462 Fset_buffer (w
->buffer
);
2463 /* This computation used to temporarily move point, but that can
2464 have unwanted side effects due to text properties. */
2465 pos
= *vmotion (startpos
, -top
, w
);
2467 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2468 w
->window_end_valid
= Qnil
;
2469 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2470 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2472 /* We need to do this, so that the window-scroll-functions
2474 w
->optional_new_start
= Qt
;
2476 set_buffer_internal (obuf
);
2482 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2483 1, 2, "bDelete windows on (buffer): ",
2484 doc
: /* Delete all windows showing BUFFER.
2485 BUFFER must be a buffer or the name of an existing buffer.
2486 Optional second argument FRAME controls which frames are affected.
2487 If optional argument FRAME is `visible', search all visible frames.
2488 If FRAME is 0, search all visible and iconified frames.
2489 If FRAME is nil, search all frames.
2490 If FRAME is t, search only the selected frame.
2491 If FRAME is a frame, search only that frame. */)
2493 Lisp_Object buffer
, frame
;
2495 /* FRAME uses t and nil to mean the opposite of what window_loop
2499 else if (EQ (frame
, Qt
))
2504 buffer
= Fget_buffer (buffer
);
2505 CHECK_BUFFER (buffer
);
2506 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2512 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2513 Sreplace_buffer_in_windows
,
2514 1, 1, "bReplace buffer in windows: ",
2515 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2516 BUFFER may be a buffer or the name of an existing buffer. */)
2522 buffer
= Fget_buffer (buffer
);
2523 CHECK_BUFFER (buffer
);
2524 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2529 /* Replace BUFFER with some other buffer in all windows
2530 of all frames, even those on other keyboards. */
2533 replace_buffer_in_all_windows (buffer
)
2536 Lisp_Object tail
, frame
;
2538 /* A single call to window_loop won't do the job
2539 because it only considers frames on the current keyboard.
2540 So loop manually over frames, and handle each one. */
2541 FOR_EACH_FRAME (tail
, frame
)
2542 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2545 /* Set the height of WINDOW and all its inferiors. */
2547 /* The smallest acceptable dimensions for a window. Anything smaller
2548 might crash Emacs. */
2550 #define MIN_SAFE_WINDOW_WIDTH (2)
2551 #define MIN_SAFE_WINDOW_HEIGHT (1)
2553 /* For wp non-zero the total number of columns of window w. Otherwise
2554 the total number of lines of w. */
2556 #define WINDOW_TOTAL_SIZE(w, wp) \
2557 (wp ? WINDOW_TOTAL_COLS (w) : WINDOW_TOTAL_LINES (w))
2559 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2560 minimum allowable size. */
2563 check_frame_size (frame
, rows
, cols
)
2567 /* For height, we have to see:
2568 how many windows the frame has at minimum (one or two),
2569 and whether it has a menu bar or other special stuff at the top. */
2571 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2572 ? MIN_SAFE_WINDOW_HEIGHT
2573 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2575 if (FRAME_TOP_MARGIN (frame
) > 0)
2576 min_height
+= FRAME_TOP_MARGIN (frame
);
2578 if (*rows
< min_height
)
2580 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2581 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2584 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2585 check if W's width can be changed, otherwise check W's height.
2586 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2587 siblings, too. If none of the siblings is resizable, WINDOW isn't
2591 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2593 int width_p
, check_siblings_p
;
2598 if (!NILP (w
->hchild
))
2600 c
= XWINDOW (w
->hchild
);
2604 /* A horizontal combination is fixed-width if all of if its
2606 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2607 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2608 fixed_p
= c
== NULL
;
2612 /* A horizontal combination is fixed-height if one of if its
2614 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2615 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2616 fixed_p
= c
!= NULL
;
2619 else if (!NILP (w
->vchild
))
2621 c
= XWINDOW (w
->vchild
);
2625 /* A vertical combination is fixed-width if one of if its
2627 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2628 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2629 fixed_p
= c
!= NULL
;
2633 /* A vertical combination is fixed-height if all of if its
2635 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2636 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2637 fixed_p
= c
== NULL
;
2640 else if (BUFFERP (w
->buffer
))
2642 struct buffer
*old
= current_buffer
;
2645 current_buffer
= XBUFFER (w
->buffer
);
2646 val
= find_symbol_value (Qwindow_size_fixed
);
2647 current_buffer
= old
;
2650 if (!EQ (val
, Qunbound
))
2652 fixed_p
= !NILP (val
);
2655 && ((EQ (val
, Qheight
) && width_p
)
2656 || (EQ (val
, Qwidth
) && !width_p
)))
2660 /* Can't tell if this one is resizable without looking at
2661 siblings. If all siblings are fixed-size this one is too. */
2662 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2666 for (child
= w
->prev
; WINDOWP (child
); child
= XWINDOW (child
)->prev
)
2667 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2671 for (child
= w
->next
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
2672 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2685 /* Return minimum size of leaf window W. WIDTH_P non-zero means return
2686 the minimum width of W, WIDTH_P zero means return the minimum height
2687 of W. SAFE_P non-zero means ignore window-min-height|width but just
2688 return values that won't crash Emacs and don't hide components like
2689 fringes, scrollbars, or modelines. If WIDTH_P is zero and W is the
2690 minibuffer window, always return 1. */
2693 window_min_size_2 (w
, width_p
, safe_p
)
2695 int width_p
, safe_p
;
2697 /* We should consider buffer-local values of window_min_height and
2698 window_min_width here. */
2701 int safe_size
= (MIN_SAFE_WINDOW_WIDTH
2702 + WINDOW_FRINGE_COLS (w
)
2703 + WINDOW_SCROLL_BAR_COLS (w
));
2705 return safe_p
? safe_size
: max (window_min_width
, safe_size
);
2707 else if (MINI_WINDOW_P (w
))
2711 int safe_size
= (MIN_SAFE_WINDOW_HEIGHT
2712 + ((BUFFERP (w
->buffer
)
2713 && !NILP (XBUFFER (w
->buffer
)->mode_line_format
))
2716 return safe_p
? safe_size
: max (window_min_height
, safe_size
);
2720 /* Return minimum size of window W, not taking fixed-width windows into
2721 account. WIDTH_P non-zero means return the minimum width, otherwise
2722 return the minimum height. SAFE_P non-zero means ignore
2723 window-min-height|width but just return values that won't crash Emacs
2724 and don't hide components like fringes, scrollbars, or modelines. If
2725 W is a combination window, compute the minimum size from the minimum
2726 sizes of W's children. */
2729 window_min_size_1 (w
, width_p
, safe_p
)
2731 int width_p
, safe_p
;
2736 if (!NILP (w
->hchild
))
2738 /* W is a horizontal combination. */
2739 c
= XWINDOW (w
->hchild
);
2744 /* The minimum width of a horizontal combination is the sum of
2745 the minimum widths of its children. */
2748 size
+= window_min_size_1 (c
, 1, safe_p
);
2749 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2754 /* The minimum height of a horizontal combination is the
2755 maximum of the minimum heights of its children. */
2758 size
= max (window_min_size_1 (c
, 0, safe_p
), size
);
2759 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2763 else if (!NILP (w
->vchild
))
2765 /* W is a vertical combination. */
2766 c
= XWINDOW (w
->vchild
);
2771 /* The minimum width of a vertical combination is the maximum
2772 of the minimum widths of its children. */
2775 size
= max (window_min_size_1 (c
, 1, safe_p
), size
);
2776 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2781 /* The minimum height of a vertical combination is the sum of
2782 the minimum height of its children. */
2785 size
+= window_min_size_1 (c
, 0, safe_p
);
2786 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2791 /* W is a leaf window. */
2792 size
= window_min_size_2 (w
, width_p
, safe_p
);
2797 /* Return the minimum size of window W, taking fixed-size windows into
2798 account. WIDTH_P non-zero means return the minimum width, otherwise
2799 return the minimum height. SAFE_P non-zero means ignore
2800 window-min-height|width but just return values that won't crash Emacs
2801 and don't hide components like fringes, scrollbars, or modelines.
2802 IGNORE_FIXED_P non-zero means ignore if W is fixed-size. Set *FIXED
2803 to 1 if W is fixed-size unless FIXED is null. */
2806 window_min_size (w
, width_p
, safe_p
, ignore_fixed_p
, fixed
)
2808 int width_p
, safe_p
, ignore_fixed_p
, *fixed
;
2815 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2821 size
= WINDOW_TOTAL_SIZE (w
, width_p
);
2823 size
= window_min_size_1 (w
, width_p
, safe_p
);
2829 /* Adjust the margins of window W if text area is too small.
2830 Return 1 if window width is ok after adjustment; 0 if window
2831 is still too narrow. */
2834 adjust_window_margins (w
)
2837 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2838 - WINDOW_FRINGE_COLS (w
)
2839 - WINDOW_SCROLL_BAR_COLS (w
));
2840 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2841 + WINDOW_RIGHT_MARGIN_COLS (w
));
2843 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2846 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2849 /* Window's text area is too narrow, but reducing the window
2850 margins will fix that. */
2851 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2852 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2854 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2855 w
->left_margin_cols
= w
->right_margin_cols
2856 = make_number (margin_cols
/2);
2858 w
->right_margin_cols
= make_number (margin_cols
);
2861 w
->left_margin_cols
= make_number (margin_cols
);
2865 /* Calculate new sizes for windows in the list FORWARD when their
2866 compound size goes from TOTAL to SIZE. TOTAL must be greater than
2867 SIZE. The number of windows in FORWARD is NCHILDREN, and the number
2868 that can shrink is SHRINKABLE. Fixed-size windows may be shrunk if
2869 and only if RESIZE_FIXED_P is non-zero. WIDTH_P non-zero means
2870 shrink columns, otherwise shrink lines.
2872 SAFE_P zero means windows may be sized down to window-min-height
2873 lines (window-min-window columns for WIDTH_P non-zero). SAFE_P
2874 non-zero means windows may be sized down to their minimum safe sizes
2875 taking into account the space needed to display modelines, fringes,
2878 This function returns an allocated array of new sizes that the caller
2879 must free. A size -1 means the window is fixed and RESIZE_FIXED_P is
2880 zero. A size zero means the window shall be deleted. Array index 0
2881 refers to the first window in FORWARD, 1 to the second, and so on.
2883 This function resizes windows proportionally to their size. It also
2884 tries to preserve smaller windows by resizing larger windows before
2885 resizing any window to zero. If resize_proportionally is non-nil for
2886 a specific window, it will attempt to strictly resize that window
2887 proportionally, even at the expense of deleting smaller windows. */
2889 shrink_windows (total
, size
, nchildren
, shrinkable
, resize_fixed_p
,
2890 forward
, width_p
, safe_p
)
2891 int total
, size
, nchildren
, shrinkable
;
2892 int resize_fixed_p
, width_p
, safe_p
;
2893 Lisp_Object forward
;
2895 int available_resize
= 0;
2896 int *new_sizes
, *min_sizes
;
2899 int smallest
= total
;
2900 int total_removed
= 0;
2901 int total_shrink
= total
- size
;
2904 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2905 min_sizes
= xmalloc (sizeof (*min_sizes
) * nchildren
);
2907 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2911 c
= XWINDOW (child
);
2912 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
2914 if (!resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2918 new_sizes
[i
] = child_size
;
2919 min_sizes
[i
] = window_min_size_1 (c
, width_p
, safe_p
);
2920 if (child_size
> min_sizes
[i
]
2921 && NILP (c
->resize_proportionally
))
2922 available_resize
+= child_size
- min_sizes
[i
];
2925 /* We might need to shrink some windows to zero. Find the smallest
2926 windows and set them to 0 until we can fulfil the new size. */
2928 while (shrinkable
> 1 && size
+ available_resize
< total
)
2930 for (i
= 0; i
< nchildren
; ++i
)
2931 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2932 smallest
= new_sizes
[i
];
2934 for (i
= 0; i
< nchildren
; ++i
)
2935 if (new_sizes
[i
] == smallest
)
2937 /* Resize this window down to zero. */
2939 if (smallest
> min_sizes
[i
])
2940 available_resize
-= smallest
- min_sizes
[i
];
2941 available_resize
+= smallest
;
2943 total_removed
+= smallest
;
2945 /* We don't know what the smallest is now. */
2948 /* Out of for, just remove one window at the time and
2949 check again if we have enough space. */
2954 /* Now, calculate the new sizes. Try to shrink each window
2955 proportional to its size. */
2956 for (i
= 0; i
< nchildren
; ++i
)
2958 if (new_sizes
[i
] > min_sizes
[i
])
2960 int to_shrink
= total_shrink
* new_sizes
[i
] / total
;
2962 if (new_sizes
[i
] - to_shrink
< min_sizes
[i
])
2963 to_shrink
= new_sizes
[i
] - min_sizes
[i
];
2964 new_sizes
[i
] -= to_shrink
;
2965 total_removed
+= to_shrink
;
2969 /* Any reminder due to rounding, we just subtract from windows
2970 that are left and still can be shrunk. */
2971 while (total_shrink
> total_removed
)
2973 int nonzero_sizes
= 0;
2974 int nonzero_idx
= -1;
2976 for (i
= 0; i
< nchildren
; ++i
)
2977 if (new_sizes
[i
] > 0)
2983 for (i
= 0; i
< nchildren
; ++i
)
2984 if (new_sizes
[i
] > min_sizes
[i
])
2989 /* Out of for, just shrink one window at the time and
2990 check again if we have enough space. */
2994 /* Special case, only one window left. */
2995 if (nonzero_sizes
== 1)
2999 /* Any surplus due to rounding, we add to windows that are left. */
3000 while (total_shrink
< total_removed
)
3002 for (i
= 0; i
< nchildren
; ++i
)
3004 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
3018 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
3019 WINDOW's width. Resize WINDOW's children, if any, so that they keep
3020 their proportionate size relative to WINDOW.
3022 If FIRST_ONLY is 1, change only the first of WINDOW's children when
3023 they are in series. If LAST_ONLY is 1, change only the last of
3024 WINDOW's children when they are in series.
3026 Propagate WINDOW's top or left edge position to children. Delete
3027 windows that become too small unless NODELETE_P is 1. When
3028 NODELETE_P equals 2 do not honor settings for window-min-height and
3029 window-min-width when resizing windows but use safe defaults instead.
3030 This should give better behavior when resizing frames. */
3033 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
3035 int size
, width_p
, nodelete_p
;
3036 int first_only
, last_only
;
3038 struct window
*w
= XWINDOW (window
);
3040 Lisp_Object child
, *forward
, *sideward
;
3041 int old_size
= WINDOW_TOTAL_SIZE (w
, width_p
);
3043 size
= max (0, size
);
3045 /* Delete WINDOW if it's too small. */
3046 if (nodelete_p
!= 1 && !NILP (w
->parent
)
3047 && size
< window_min_size_1 (w
, width_p
, nodelete_p
== 2))
3049 delete_window (window
);
3053 /* Set redisplay hints. */
3054 w
->last_modified
= make_number (0);
3055 w
->last_overlay_modified
= make_number (0);
3056 windows_or_buffers_changed
++;
3057 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3061 sideward
= &w
->vchild
;
3062 forward
= &w
->hchild
;
3063 w
->total_cols
= make_number (size
);
3064 adjust_window_margins (w
);
3068 sideward
= &w
->hchild
;
3069 forward
= &w
->vchild
;
3070 w
->total_lines
= make_number (size
);
3071 w
->orig_total_lines
= Qnil
;
3074 if (!NILP (*sideward
))
3076 /* We have a chain of parallel siblings whose size should all change. */
3077 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3079 c
= XWINDOW (child
);
3081 c
->left_col
= w
->left_col
;
3083 c
->top_line
= w
->top_line
;
3084 size_window (child
, size
, width_p
, nodelete_p
,
3085 first_only
, last_only
);
3088 else if (!NILP (*forward
) && last_only
)
3090 /* Change the last in a series of siblings. */
3091 Lisp_Object last_child
;
3094 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3096 c
= XWINDOW (child
);
3100 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3101 size_window (last_child
, size
- old_size
+ child_size
,
3102 width_p
, nodelete_p
, first_only
, last_only
);
3104 else if (!NILP (*forward
) && first_only
)
3106 /* Change the first in a series of siblings. */
3110 c
= XWINDOW (child
);
3113 c
->left_col
= w
->left_col
;
3115 c
->top_line
= w
->top_line
;
3117 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3118 size_window (child
, size
- old_size
+ child_size
,
3119 width_p
, nodelete_p
, first_only
, last_only
);
3121 else if (!NILP (*forward
))
3123 int fixed_size
, each
, extra
, n
;
3124 int resize_fixed_p
, nfixed
;
3125 int last_pos
, first_pos
, nchildren
, total
;
3126 int *new_sizes
= NULL
;
3128 /* Determine the fixed-size portion of this window, and the
3129 number of child windows. */
3130 fixed_size
= nchildren
= nfixed
= total
= 0;
3131 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3135 c
= XWINDOW (child
);
3136 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3137 total
+= child_size
;
3139 if (window_fixed_size_p (c
, width_p
, 0))
3141 fixed_size
+= child_size
;
3146 /* If the new size is smaller than fixed_size, or if there
3147 aren't any resizable windows, allow resizing fixed-size
3149 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3151 /* Compute how many lines/columns to add/remove to each child. The
3152 value of extra takes care of rounding errors. */
3153 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3154 if (size
< total
&& n
> 1)
3155 new_sizes
= shrink_windows (total
, size
, nchildren
, n
,
3156 resize_fixed_p
, *forward
, width_p
,
3160 each
= (size
- total
) / n
;
3161 extra
= (size
- total
) - n
* each
;
3164 /* Compute new children heights and edge positions. */
3165 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3166 last_pos
= first_pos
;
3167 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3169 int new_size
, old_size
;
3171 c
= XWINDOW (child
);
3172 old_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3173 new_size
= old_size
;
3175 /* The top or left edge position of this child equals the
3176 bottom or right edge of its predecessor. */
3178 c
->left_col
= make_number (last_pos
);
3180 c
->top_line
= make_number (last_pos
);
3182 /* If this child can be resized, do it. */
3183 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3185 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3189 /* Set new size. Note that size_window also propagates
3190 edge positions to children, so it's not a no-op if we
3191 didn't change the child's size. */
3192 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3194 /* Remember the bottom/right edge position of this child; it
3195 will be used to set the top/left edge of the next child. */
3196 last_pos
+= new_size
;
3201 /* We should have covered the parent exactly with child windows. */
3202 xassert (size
== last_pos
- first_pos
);
3204 /* Now delete any children that became too small. */
3205 if (nodelete_p
!= 1)
3206 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3210 c
= XWINDOW (child
);
3211 child_size
= WINDOW_TOTAL_SIZE (c
, width_p
);
3212 size_window (child
, child_size
, width_p
, nodelete_p
,
3213 first_only
, last_only
);
3218 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3219 WINDOW's children. NODELETE zero means windows that have become
3220 smaller than window-min-height in the process may be deleted.
3221 NODELETE 1 means never delete windows that become too small in the
3222 process. (The caller should check later and do so if appropriate.)
3223 NODELETE 2 means delete only windows that have become too small to be
3224 displayed correctly. */
3227 set_window_height (window
, height
, nodelete
)
3232 size_window (window
, height
, 0, nodelete
, 0, 0);
3235 /* Set WINDOW's width to WIDTH, and recursively change the width of
3236 WINDOW's children. NODELETE zero means windows that have become
3237 smaller than window-min-width in the process may be deleted.
3238 NODELETE 1 means never delete windows that become too small in the
3239 process. (The caller should check later and do so if appropriate.)
3240 NODELETE 2 means delete only windows that have become too small to be
3241 displayed correctly. */
3244 set_window_width (window
, width
, nodelete
)
3249 size_window (window
, width
, 1, nodelete
, 0, 0);
3252 /* Change window heights in windows rooted in WINDOW by N lines. */
3255 change_window_heights (window
, n
)
3259 struct window
*w
= XWINDOW (window
);
3261 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3262 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3264 if (INTEGERP (w
->orig_top_line
))
3265 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3266 if (INTEGERP (w
->orig_total_lines
))
3267 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3269 /* Handle just the top child in a vertical split. */
3270 if (!NILP (w
->vchild
))
3271 change_window_heights (w
->vchild
, n
);
3273 /* Adjust all children in a horizontal split. */
3274 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3276 w
= XWINDOW (window
);
3277 change_window_heights (window
, n
);
3282 int window_select_count
;
3284 EXFUN (Fset_window_fringes
, 4);
3285 EXFUN (Fset_window_scroll_bars
, 4);
3288 run_funs (Lisp_Object funs
)
3290 for (; CONSP (funs
); funs
= XCDR (funs
))
3291 if (!EQ (XCAR (funs
), Qt
))
3292 call0 (XCAR (funs
));
3295 static Lisp_Object
select_window_norecord (Lisp_Object window
);
3298 run_window_configuration_change_hook (struct frame
*f
)
3300 int count
= SPECPDL_INDEX ();
3301 Lisp_Object frame
, global_wcch
3302 = Fdefault_value (Qwindow_configuration_change_hook
);
3303 XSETFRAME (frame
, f
);
3305 if (NILP (Vrun_hooks
))
3308 if (SELECTED_FRAME () != f
)
3310 record_unwind_protect (Fselect_frame
, Fselected_frame ());
3311 Fselect_frame (frame
);
3314 /* Use the right buffer. Matters when running the local hooks. */
3315 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3317 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3318 Fset_buffer (Fwindow_buffer (Qnil
));
3321 /* Look for buffer-local values. */
3323 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3324 for (; CONSP (windows
); windows
= XCDR (windows
))
3326 Lisp_Object window
= XCAR (windows
);
3327 Lisp_Object buffer
= Fwindow_buffer (window
);
3328 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3331 int count
= SPECPDL_INDEX ();
3332 record_unwind_protect (select_window_norecord
, Fselected_window ());
3333 select_window_norecord (window
);
3334 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3336 unbind_to (count
, Qnil
);
3341 run_funs (global_wcch
);
3342 unbind_to (count
, Qnil
);
3345 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3346 means it's allowed to run hooks. See make_frame for a case where
3347 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3348 margins, fringes, and scroll-bar settings of the window are not
3349 reset from the buffer's local settings. */
3352 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3353 Lisp_Object window
, buffer
;
3354 int run_hooks_p
, keep_margins_p
;
3356 struct window
*w
= XWINDOW (window
);
3357 struct buffer
*b
= XBUFFER (buffer
);
3358 int count
= SPECPDL_INDEX ();
3359 int samebuf
= EQ (buffer
, w
->buffer
);
3363 if (EQ (window
, selected_window
))
3364 b
->last_selected_window
= window
;
3366 /* Let redisplay errors through. */
3367 b
->display_error_modiff
= 0;
3369 /* Update time stamps of buffer display. */
3370 if (INTEGERP (b
->display_count
))
3371 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3372 b
->display_time
= Fcurrent_time ();
3374 XSETFASTINT (w
->window_end_pos
, 0);
3375 XSETFASTINT (w
->window_end_vpos
, 0);
3376 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3377 w
->window_end_valid
= Qnil
;
3378 if (!(keep_margins_p
&& samebuf
))
3379 { /* If we're not actually changing the buffer, Don't reset hscroll and
3380 vscroll. This case happens for example when called from
3381 change_frame_size_1, where we use a dummy call to
3382 Fset_window_buffer on the frame's selected window (and no other)
3383 just in order to run window-configuration-change-hook.
3384 Resetting hscroll and vscroll here is problematic for things like
3385 image-mode and doc-view-mode since it resets the image's position
3386 whenever we resize the frame. */
3387 w
->hscroll
= w
->min_hscroll
= make_number (0);
3389 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3390 set_marker_restricted (w
->start
,
3391 make_number (b
->last_window_start
),
3393 w
->start_at_line_beg
= Qnil
;
3394 w
->force_start
= Qnil
;
3395 XSETFASTINT (w
->last_modified
, 0);
3396 XSETFASTINT (w
->last_overlay_modified
, 0);
3398 /* Maybe we could move this into the `if' but it's not obviously safe and
3399 I doubt it's worth the trouble. */
3400 windows_or_buffers_changed
++;
3402 /* We must select BUFFER for running the window-scroll-functions. */
3403 /* We can't check ! NILP (Vwindow_scroll_functions) here
3404 because that might itself be a local variable. */
3405 if (window_initialized
)
3407 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3408 Fset_buffer (buffer
);
3411 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3413 if (!keep_margins_p
)
3415 /* Set left and right marginal area width etc. from buffer. */
3417 /* This may call adjust_window_margins three times, so
3418 temporarily disable window margins. */
3419 Lisp_Object save_left
= w
->left_margin_cols
;
3420 Lisp_Object save_right
= w
->right_margin_cols
;
3422 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3424 Fset_window_fringes (window
,
3425 b
->left_fringe_width
, b
->right_fringe_width
,
3426 b
->fringes_outside_margins
);
3428 Fset_window_scroll_bars (window
,
3429 b
->scroll_bar_width
,
3430 b
->vertical_scroll_bar_type
, Qnil
);
3432 w
->left_margin_cols
= save_left
;
3433 w
->right_margin_cols
= save_right
;
3435 Fset_window_margins (window
,
3436 b
->left_margin_cols
, b
->right_margin_cols
);
3441 if (! NILP (Vwindow_scroll_functions
))
3442 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3443 Fmarker_position (w
->start
));
3444 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3447 unbind_to (count
, Qnil
);
3451 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3452 doc
: /* Make WINDOW display BUFFER as its contents.
3453 BUFFER can be a buffer or the name of an existing buffer.
3454 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3455 display margins, fringe widths, and scroll bar settings are maintained;
3456 the default is to reset these from BUFFER's local settings or the frame
3459 This function runs the hook `window-scroll-functions'. */)
3460 (window
, buffer
, keep_margins
)
3461 register Lisp_Object window
, buffer
, keep_margins
;
3463 register Lisp_Object tem
;
3464 register struct window
*w
= decode_window (window
);
3466 XSETWINDOW (window
, w
);
3467 buffer
= Fget_buffer (buffer
);
3468 CHECK_BUFFER (buffer
);
3470 if (NILP (XBUFFER (buffer
)->name
))
3471 error ("Attempt to display deleted buffer");
3475 error ("Window is deleted");
3476 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3477 is first being set up. */
3479 if (!EQ (tem
, buffer
))
3480 if (EQ (w
->dedicated
, Qt
))
3481 error ("Window is dedicated to `%s'", SDATA (XBUFFER (tem
)->name
));
3483 w
->dedicated
= Qnil
;
3488 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3492 /* Note that selected_window can be nil
3493 when this is called from Fset_window_configuration. */
3495 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3496 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3497 If WINDOW is not already selected, make WINDOW's buffer current
3498 and make WINDOW the frame's selected window. Return WINDOW.
3499 Optional second arg NORECORD non-nil means do not put this buffer
3500 at the front of the list of recently selected ones.
3502 Note that the main editor command loop selects the buffer of the
3503 selected window before each command. */)
3505 register Lisp_Object window
, norecord
;
3507 register struct window
*w
;
3508 register struct window
*ow
;
3511 CHECK_LIVE_WINDOW (window
);
3513 w
= XWINDOW (window
);
3514 w
->frozen_window_start_p
= 0;
3516 if (NILP (norecord
))
3518 ++window_select_count
;
3519 XSETFASTINT (w
->use_time
, window_select_count
);
3522 if (EQ (window
, selected_window
))
3525 sf
= SELECTED_FRAME ();
3526 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3528 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3529 /* Use this rather than Fhandle_switch_frame
3530 so that FRAME_FOCUS_FRAME is moved appropriately as we
3531 move around in the state where a minibuffer in a separate
3533 Fselect_frame (WINDOW_FRAME (w
));
3534 /* Fselect_frame called us back so we've done all the work already. */
3535 eassert (EQ (window
, selected_window
));
3539 sf
->selected_window
= window
;
3541 /* Store the current buffer's actual point into the
3542 old selected window. It belongs to that window,
3543 and when the window is not selected, must be in the window. */
3544 if (!NILP (selected_window
))
3546 ow
= XWINDOW (selected_window
);
3547 if (! NILP (ow
->buffer
))
3548 set_marker_both (ow
->pointm
, ow
->buffer
,
3549 BUF_PT (XBUFFER (ow
->buffer
)),
3550 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3553 selected_window
= window
;
3555 if (NILP (norecord
))
3556 record_buffer (w
->buffer
);
3557 Fset_buffer (w
->buffer
);
3559 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3561 /* Go to the point recorded in the window.
3562 This is important when the buffer is in more
3563 than one window. It also matters when
3564 redisplay_window has altered point after scrolling,
3565 because it makes the change only in the window. */
3567 register int new_point
= marker_position (w
->pointm
);
3568 if (new_point
< BEGV
)
3570 else if (new_point
> ZV
)
3576 windows_or_buffers_changed
++;
3581 select_window_norecord (window
)
3584 return Fselect_window (window
, Qt
);
3588 display_buffer (buffer
, not_this_window_p
, override_frame
)
3589 Lisp_Object buffer
, not_this_window_p
, override_frame
;
3591 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3594 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3596 doc
: /* Force all windows to be updated on next redisplay.
3597 If optional arg OBJECT is a window, force redisplay of that window only.
3598 If OBJECT is a buffer or buffer name, force redisplay of all windows
3599 displaying that buffer. */)
3605 windows_or_buffers_changed
++;
3606 update_mode_lines
++;
3610 if (WINDOWP (object
))
3612 struct window
*w
= XWINDOW (object
);
3613 mark_window_display_accurate (object
, 0);
3614 w
->update_mode_line
= Qt
;
3615 if (BUFFERP (w
->buffer
))
3616 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3617 ++update_mode_lines
;
3621 if (STRINGP (object
))
3622 object
= Fget_buffer (object
);
3623 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3625 /* Walk all windows looking for buffer, and force update
3626 of each of those windows. */
3628 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3629 return NILP (object
) ? Qnil
: Qt
;
3632 /* If nothing suitable was found, just return.
3633 We could signal an error, but this feature will typically be used
3634 asynchronously in timers or process sentinels, so we don't. */
3640 temp_output_buffer_show (buf
)
3641 register Lisp_Object buf
;
3643 register struct buffer
*old
= current_buffer
;
3644 register Lisp_Object window
;
3645 register struct window
*w
;
3647 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3650 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3654 #if 0 /* rms: there should be no reason for this. */
3655 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3657 set_buffer_internal (old
);
3659 if (!NILP (Vtemp_buffer_show_function
))
3660 call1 (Vtemp_buffer_show_function
, buf
);
3663 window
= display_buffer (buf
, Qnil
, Qnil
);
3665 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3666 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3667 Vminibuf_scroll_window
= window
;
3668 w
= XWINDOW (window
);
3669 XSETFASTINT (w
->hscroll
, 0);
3670 XSETFASTINT (w
->min_hscroll
, 0);
3671 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3672 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3674 /* Run temp-buffer-show-hook, with the chosen window selected
3675 and its buffer current. */
3677 if (!NILP (Vrun_hooks
)
3678 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3679 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3681 int count
= SPECPDL_INDEX ();
3682 Lisp_Object prev_window
, prev_buffer
;
3683 prev_window
= selected_window
;
3684 XSETBUFFER (prev_buffer
, old
);
3686 /* Select the window that was chosen, for running the hook.
3687 Note: Both Fselect_window and select_window_norecord may
3688 set-buffer to the buffer displayed in the window,
3689 so we need to save the current buffer. --stef */
3690 record_unwind_protect (Fset_buffer
, prev_buffer
);
3691 record_unwind_protect (select_window_norecord
, prev_window
);
3692 Fselect_window (window
, Qt
);
3693 Fset_buffer (w
->buffer
);
3694 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3695 unbind_to (count
, Qnil
);
3701 make_dummy_parent (window
)
3705 register struct window
*o
, *p
;
3708 o
= XWINDOW (window
);
3709 p
= allocate_window ();
3710 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3711 ((struct Lisp_Vector
*) p
)->contents
[i
]
3712 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3713 XSETWINDOW (new, p
);
3716 XSETFASTINT (p
->sequence_number
, sequence_number
);
3718 /* Put new into window structure in place of window */
3719 replace_window (window
, new);
3732 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3733 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3734 WINDOW defaults to selected one and SIZE to half its size.
3735 If optional third arg HORFLAG is non-nil, split side by side
3736 and put SIZE columns in the first of the pair. In that case,
3737 SIZE includes that window's scroll bar, or the divider column to its right.
3738 Interactively, all arguments are nil.
3740 Returns the newly created window (which is the lower or rightmost one).
3741 The upper or leftmost window is the original one, and remains selected
3742 if it was selected before.
3744 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3745 (window
, size
, horflag
)
3746 Lisp_Object window
, size
, horflag
;
3748 register Lisp_Object
new;
3749 register struct window
*o
, *p
;
3751 register int size_int
;
3754 window
= selected_window
;
3756 CHECK_LIVE_WINDOW (window
);
3758 o
= XWINDOW (window
);
3759 fo
= XFRAME (WINDOW_FRAME (o
));
3763 if (!NILP (horflag
))
3764 /* Calculate the size of the left-hand window, by dividing
3765 the usable space in columns by two.
3766 We round up, since the left-hand window may include
3767 a dividing line, while the right-hand may not. */
3768 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3770 size_int
= XFASTINT (o
->total_lines
) >> 1;
3774 CHECK_NUMBER (size
);
3775 size_int
= XINT (size
);
3778 if (MINI_WINDOW_P (o
))
3779 error ("Attempt to split minibuffer window");
3780 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3781 error ("Attempt to split fixed-size window");
3785 int window_safe_height
= window_min_size_2 (o
, 0, 0);
3787 if (size_int
< window_safe_height
)
3788 error ("Window height %d too small (after splitting)", size_int
);
3789 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
3790 error ("Window height %d too small (after splitting)",
3791 XFASTINT (o
->total_lines
) - size_int
);
3792 if (NILP (o
->parent
)
3793 || NILP (XWINDOW (o
->parent
)->vchild
))
3795 make_dummy_parent (window
);
3797 XWINDOW (new)->vchild
= window
;
3802 int window_safe_width
= window_min_size_2 (o
, 1, 0);
3804 if (size_int
< window_safe_width
)
3805 error ("Window width %d too small (after splitting)", size_int
);
3806 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
3807 error ("Window width %d too small (after splitting)",
3808 XFASTINT (o
->total_cols
) - size_int
);
3809 if (NILP (o
->parent
)
3810 || NILP (XWINDOW (o
->parent
)->hchild
))
3812 make_dummy_parent (window
);
3814 XWINDOW (new)->hchild
= window
;
3818 /* Now we know that window's parent is a vertical combination
3819 if we are dividing vertically, or a horizontal combination
3820 if we are making side-by-side windows */
3822 windows_or_buffers_changed
++;
3823 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3824 new = make_window ();
3827 p
->frame
= o
->frame
;
3829 if (!NILP (p
->next
))
3830 XWINDOW (p
->next
)->prev
= new;
3833 p
->parent
= o
->parent
;
3835 p
->window_end_valid
= Qnil
;
3836 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3838 /* Duplicate special geometry settings. */
3840 p
->left_margin_cols
= o
->left_margin_cols
;
3841 p
->right_margin_cols
= o
->right_margin_cols
;
3842 p
->left_fringe_width
= o
->left_fringe_width
;
3843 p
->right_fringe_width
= o
->right_fringe_width
;
3844 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3845 p
->scroll_bar_width
= o
->scroll_bar_width
;
3846 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3848 /* Apportion the available frame space among the two new windows */
3850 if (!NILP (horflag
))
3852 p
->total_lines
= o
->total_lines
;
3853 p
->top_line
= o
->top_line
;
3854 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3855 XSETFASTINT (o
->total_cols
, size_int
);
3856 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3857 adjust_window_margins (p
);
3858 adjust_window_margins (o
);
3862 p
->left_col
= o
->left_col
;
3863 p
->total_cols
= o
->total_cols
;
3864 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3865 XSETFASTINT (o
->total_lines
, size_int
);
3866 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3869 /* Adjust glyph matrices. */
3872 Fset_window_buffer (new, o
->buffer
, Qt
);
3876 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3877 doc
: /* Make current window ARG lines bigger.
3878 From program, optional second arg non-nil means grow sideways ARG columns.
3879 Interactively, if an argument is not given, make the window one line bigger.
3880 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
3881 This function can delete windows, even the second window, if they get
3884 Lisp_Object arg
, horizontal
;
3887 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
3889 run_window_configuration_change_hook (SELECTED_FRAME ());
3894 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3895 doc
: /* Make current window ARG lines smaller.
3896 From program, optional second arg non-nil means shrink sideways arg columns.
3897 Interactively, if an argument is not given, make the window one line smaller.
3898 Only siblings to the right or below are changed. */)
3900 Lisp_Object arg
, side
;
3903 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3905 run_window_configuration_change_hook (SELECTED_FRAME ());
3911 window_height (window
)
3914 register struct window
*p
= XWINDOW (window
);
3915 return WINDOW_TOTAL_LINES (p
);
3919 window_width (window
)
3922 register struct window
*p
= XWINDOW (window
);
3923 return WINDOW_TOTAL_COLS (p
);
3928 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3930 #define CURSIZE(w) \
3931 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3934 /* Enlarge WINDOW by DELTA. HORIZ_FLAG nonzero means enlarge it
3935 horizontally; zero means do it vertically.
3937 Siblings of the selected window are resized to fulfill the size
3938 request. If they become too small in the process, they may be
3942 enlarge_window (window
, delta
, horiz_flag
)
3944 int delta
, horiz_flag
;
3946 Lisp_Object parent
, next
, prev
;
3950 int (*sizefun
) P_ ((Lisp_Object
))
3951 = horiz_flag
? window_width
: window_height
;
3952 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3953 = (horiz_flag
? set_window_width
: set_window_height
);
3955 /* Give up if this window cannot be resized. */
3956 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3957 error ("Window is not resizable");
3959 /* Find the parent of the selected window. */
3962 p
= XWINDOW (window
);
3968 error ("No other window to side of this one");
3973 ? !NILP (XWINDOW (parent
)->hchild
)
3974 : !NILP (XWINDOW (parent
)->vchild
))
3980 sizep
= &CURSIZE (window
);
3983 register int maxdelta
;
3985 /* Compute the maximum size increment this window can have. */
3987 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3988 /* This is a main window followed by a minibuffer. */
3989 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3990 - window_min_size (XWINDOW (p
->next
),
3991 horiz_flag
, 0, 0, 0))
3992 /* This is a minibuffer following a main window. */
3993 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3994 - window_min_size (XWINDOW (p
->prev
),
3995 horiz_flag
, 0, 0, 0))
3996 /* This is a frame with only one window, a minibuffer-only
3997 or a minibufferless frame. */
4000 if (delta
> maxdelta
)
4001 /* This case traps trying to make the minibuffer
4002 the full frame, or make the only window aside from the
4003 minibuffer the full frame. */
4007 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
),
4008 horiz_flag
, 0, 0, 0))
4010 delete_window (window
);
4017 /* Find the total we can get from other siblings without deleting them. */
4019 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4020 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4021 horiz_flag
, 0, 0, 0);
4022 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4023 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4024 horiz_flag
, 0, 0, 0);
4026 /* If we can get it all from them without deleting them, do so. */
4027 if (delta
<= maximum
)
4029 Lisp_Object first_unaffected
;
4030 Lisp_Object first_affected
;
4035 first_affected
= window
;
4036 /* Look at one sibling at a time,
4037 moving away from this window in both directions alternately,
4038 and take as much as we can get without deleting that sibling. */
4040 && (!NILP (next
) || !NILP (prev
)))
4044 int this_one
= ((*sizefun
) (next
)
4045 - window_min_size (XWINDOW (next
), horiz_flag
,
4049 if (this_one
> delta
)
4052 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4053 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4058 next
= XWINDOW (next
)->next
;
4066 int this_one
= ((*sizefun
) (prev
)
4067 - window_min_size (XWINDOW (prev
), horiz_flag
,
4071 if (this_one
> delta
)
4074 first_affected
= prev
;
4076 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4077 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4082 prev
= XWINDOW (prev
)->prev
;
4086 xassert (delta
== 0);
4088 /* Now recalculate the edge positions of all the windows affected,
4089 based on the new sizes. */
4090 first_unaffected
= next
;
4091 prev
= first_affected
;
4092 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4093 prev
= next
, next
= XWINDOW (next
)->next
)
4095 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4096 /* This does not change size of NEXT,
4097 but it propagates the new top edge to its children */
4098 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4103 register int delta1
;
4104 register int opht
= (*sizefun
) (parent
);
4106 if (opht
<= XINT (*sizep
) + delta
)
4108 /* If trying to grow this window to or beyond size of the parent,
4109 just delete all the sibling windows. */
4110 Lisp_Object start
, tem
, next
;
4112 start
= XWINDOW (parent
)->vchild
;
4114 start
= XWINDOW (parent
)->hchild
;
4116 /* Delete any siblings that come after WINDOW. */
4117 tem
= XWINDOW (window
)->next
;
4118 while (! NILP (tem
))
4120 next
= XWINDOW (tem
)->next
;
4121 delete_window (tem
);
4125 /* Delete any siblings that come after WINDOW.
4126 Note that if START is not WINDOW, then WINDOW still
4127 has siblings, so WINDOW has not yet replaced its parent. */
4129 while (! EQ (tem
, window
))
4131 next
= XWINDOW (tem
)->next
;
4132 delete_window (tem
);
4138 /* Otherwise, make delta1 just right so that if we add
4139 delta1 lines to this window and to the parent, and then
4140 shrink the parent back to its original size, the new
4141 proportional size of this window will increase by delta.
4143 The function size_window will compute the new height h'
4144 of the window from delta1 as:
4147 x = delta1 - delta1/n * n for the 1st resizable child
4150 where n is the number of children that can be resized.
4151 We can ignore x by choosing a delta1 that is a multiple of
4152 n. We want the height of this window to come out as
4162 The number of children n equals the number of resizable
4163 children of this window + 1 because we know window itself
4164 is resizable (otherwise we would have signaled an error).
4166 This reasoning is not correct when other windows become too
4167 small and shrink_windows refuses to delete them. Below we
4168 use resize_proportionally to work around this problem. */
4170 struct window
*w
= XWINDOW (window
);
4174 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4175 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4177 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4178 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4183 /* Add delta1 lines or columns to this window, and to the parent,
4184 keeping things consistent while not affecting siblings. */
4185 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4186 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4188 /* Squeeze out delta1 lines or columns from our parent,
4189 shrinking this window and siblings proportionately. This
4190 brings parent back to correct size. Delta1 was calculated
4191 so this makes this window the desired size, taking it all
4192 out of the siblings.
4194 Temporarily set resize_proportionally to Qt to assure that,
4195 if necessary, shrink_windows deletes smaller windows rather
4196 than shrink this window. */
4197 w
->resize_proportionally
= Qt
;
4198 (*setsizefun
) (parent
, opht
, 0);
4199 w
->resize_proportionally
= Qnil
;
4203 XSETFASTINT (p
->last_modified
, 0);
4204 XSETFASTINT (p
->last_overlay_modified
, 0);
4206 /* Adjust glyph matrices. */
4207 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4211 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4212 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4213 zero means adjust the height, moving the bottom edge.
4215 Following siblings of the selected window are resized to fulfill
4216 the size request. If they become too small in the process, they
4217 are not deleted; instead, we signal an error. */
4220 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4222 int delta
, horiz_flag
;
4224 Lisp_Object parent
, child
;
4226 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4227 int delcount
= window_deletion_count
;
4229 CHECK_WINDOW (window
);
4231 /* Give up if this window cannot be resized. */
4232 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4233 error ("Window is not resizable");
4237 Lisp_Object first_parallel
= Qnil
;
4241 /* This happens if WINDOW on the previous iteration was
4242 at top level of the window tree. */
4243 Fset_window_configuration (old_config
);
4244 error ("Specified window edge is fixed");
4247 p
= XWINDOW (window
);
4250 /* See if this level has windows in parallel in the specified
4251 direction. If so, set FIRST_PARALLEL to the first one. */
4254 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4255 first_parallel
= XWINDOW (parent
)->vchild
;
4256 else if (NILP (parent
) && !NILP (p
->next
))
4258 /* Handle the vertical chain of main window and minibuffer
4259 which has no parent. */
4260 first_parallel
= window
;
4261 while (! NILP (XWINDOW (first_parallel
)->prev
))
4262 first_parallel
= XWINDOW (first_parallel
)->prev
;
4267 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4268 first_parallel
= XWINDOW (parent
)->hchild
;
4271 /* If this level's succession is in the desired dimension,
4272 and this window is the last one, and there is no higher level,
4273 its trailing edge is fixed. */
4274 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4277 Fset_window_configuration (old_config
);
4278 error ("Specified window edge is fixed");
4281 /* Don't make this window too small. */
4282 if (XINT (CURSIZE (window
)) + delta
4283 < window_min_size_2 (XWINDOW (window
), horiz_flag
, 0))
4285 Fset_window_configuration (old_config
);
4286 error ("Cannot adjust window size as specified");
4289 /* Clear out some redisplay caches. */
4290 XSETFASTINT (p
->last_modified
, 0);
4291 XSETFASTINT (p
->last_overlay_modified
, 0);
4293 /* Adjust this window's edge. */
4294 XSETINT (CURSIZE (window
),
4295 XINT (CURSIZE (window
)) + delta
);
4297 /* If this window has following siblings in the desired dimension,
4298 make them smaller, and exit the loop.
4300 (If we reach the top of the tree and can never do this,
4301 we will fail and report an error, above.) */
4302 if (NILP (first_parallel
))
4304 if (!NILP (p
->next
))
4306 /* This may happen for the minibuffer. In that case
4307 the window_deletion_count check below does not work. */
4308 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4310 Fset_window_configuration (old_config
);
4311 error ("Cannot adjust window size as specified");
4314 XSETINT (CURBEG (p
->next
),
4315 XINT (CURBEG (p
->next
)) + delta
);
4316 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4317 horiz_flag
, 0, 1, 0);
4322 /* Here we have a chain of parallel siblings, in the other dimension.
4323 Change the size of the other siblings. */
4324 for (child
= first_parallel
;
4326 child
= XWINDOW (child
)->next
)
4327 if (! EQ (child
, window
))
4328 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4329 horiz_flag
, 0, 0, 1);
4334 /* If we made a window so small it got deleted,
4335 we failed. Report failure. */
4336 if (delcount
!= window_deletion_count
)
4338 Fset_window_configuration (old_config
);
4339 error ("Cannot adjust window size as specified");
4342 /* Adjust glyph matrices. */
4343 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4349 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4350 Sadjust_window_trailing_edge
, 3, 3, 0,
4351 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4352 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4353 Otherwise, adjust the height, moving the bottom edge.
4355 Following siblings of the selected window are resized to fulfill
4356 the size request. If they become too small in the process, they
4357 are not deleted; instead, we signal an error. */)
4358 (window
, delta
, horizontal
)
4359 Lisp_Object window
, delta
, horizontal
;
4361 CHECK_NUMBER (delta
);
4363 window
= selected_window
;
4364 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4366 run_window_configuration_change_hook
4367 (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4374 /***********************************************************************
4375 Resizing Mini-Windows
4376 ***********************************************************************/
4378 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4380 enum save_restore_action
4387 static int save_restore_orig_size
P_ ((struct window
*,
4388 enum save_restore_action
));
4390 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4391 from lowest windows first. */
4394 shrink_window_lowest_first (w
, height
)
4402 xassert (!MINI_WINDOW_P (w
));
4404 /* Set redisplay hints. */
4405 XSETFASTINT (w
->last_modified
, 0);
4406 XSETFASTINT (w
->last_overlay_modified
, 0);
4407 windows_or_buffers_changed
++;
4408 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4410 old_height
= XFASTINT (w
->total_lines
);
4411 XSETFASTINT (w
->total_lines
, height
);
4413 if (!NILP (w
->hchild
))
4415 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4417 c
= XWINDOW (child
);
4418 c
->top_line
= w
->top_line
;
4419 shrink_window_lowest_first (c
, height
);
4422 else if (!NILP (w
->vchild
))
4424 Lisp_Object last_child
;
4425 int delta
= old_height
- height
;
4430 /* Find the last child. We are taking space from lowest windows
4431 first, so we iterate over children from the last child
4433 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4436 /* Size children down to their safe heights. */
4437 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4441 c
= XWINDOW (child
);
4442 this_one
= XFASTINT (c
->total_lines
) - window_min_size_1 (c
, 0, 1);
4444 if (this_one
> delta
)
4447 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4451 /* Compute new positions. */
4452 last_top
= XINT (w
->top_line
);
4453 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4455 c
= XWINDOW (child
);
4456 c
->top_line
= make_number (last_top
);
4457 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4458 last_top
+= XFASTINT (c
->total_lines
);
4464 /* Save, restore, or check positions and sizes in the window tree
4465 rooted at W. ACTION says what to do.
4467 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4468 orig_total_lines members are valid for all windows in the window
4469 tree. Value is non-zero if they are valid.
4471 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4472 orig_top_line and orig_total_lines for all windows in the tree.
4474 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4475 stored in orig_top_line and orig_total_lines for all windows. */
4478 save_restore_orig_size (w
, action
)
4480 enum save_restore_action action
;
4486 if (!NILP (w
->hchild
))
4488 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4491 else if (!NILP (w
->vchild
))
4493 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4499 case CHECK_ORIG_SIZES
:
4500 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4504 case SAVE_ORIG_SIZES
:
4505 w
->orig_top_line
= w
->top_line
;
4506 w
->orig_total_lines
= w
->total_lines
;
4507 XSETFASTINT (w
->last_modified
, 0);
4508 XSETFASTINT (w
->last_overlay_modified
, 0);
4511 case RESTORE_ORIG_SIZES
:
4512 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4513 w
->top_line
= w
->orig_top_line
;
4514 w
->total_lines
= w
->orig_total_lines
;
4515 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4516 XSETFASTINT (w
->last_modified
, 0);
4517 XSETFASTINT (w
->last_overlay_modified
, 0);
4524 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4531 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4532 without deleting other windows. */
4535 grow_mini_window (w
, delta
)
4539 struct frame
*f
= XFRAME (w
->frame
);
4540 struct window
*root
;
4542 xassert (MINI_WINDOW_P (w
));
4543 xassert (delta
>= 0);
4545 /* Compute how much we can enlarge the mini-window without deleting
4547 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4550 int min_height
= window_min_size (root
, 0, 0, 0, 0);
4551 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4552 /* Note that the root window may already be smaller than
4554 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4559 /* Save original window sizes and positions, if not already done. */
4560 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4561 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4563 /* Shrink other windows. */
4564 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4566 /* Grow the mini-window. */
4567 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4568 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4569 XSETFASTINT (w
->last_modified
, 0);
4570 XSETFASTINT (w
->last_overlay_modified
, 0);
4577 /* Shrink mini-window W. If there is recorded info about window sizes
4578 before a call to grow_mini_window, restore recorded window sizes.
4579 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4583 shrink_mini_window (w
)
4586 struct frame
*f
= XFRAME (w
->frame
);
4587 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4589 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4591 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4593 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4594 windows_or_buffers_changed
= 1;
4596 else if (XFASTINT (w
->total_lines
) > 1)
4598 /* Distribute the additional lines of the mini-window
4599 among the other windows. */
4601 XSETWINDOW (window
, w
);
4602 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4608 /* Mark window cursors off for all windows in the window tree rooted
4609 at W by setting their phys_cursor_on_p flag to zero. Called from
4610 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4611 the frame are cleared. */
4614 mark_window_cursors_off (w
)
4619 if (!NILP (w
->hchild
))
4620 mark_window_cursors_off (XWINDOW (w
->hchild
));
4621 else if (!NILP (w
->vchild
))
4622 mark_window_cursors_off (XWINDOW (w
->vchild
));
4624 w
->phys_cursor_on_p
= 0;
4626 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4631 /* Return number of lines of text (not counting mode lines) in W. */
4634 window_internal_height (w
)
4637 int ht
= XFASTINT (w
->total_lines
);
4639 if (!MINI_WINDOW_P (w
))
4641 if (!NILP (w
->parent
)
4642 || !NILP (w
->vchild
)
4643 || !NILP (w
->hchild
)
4646 || WINDOW_WANTS_MODELINE_P (w
))
4649 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4657 /* Return the number of columns in W.
4658 Don't count columns occupied by scroll bars or the vertical bar
4659 separating W from the sibling to its right. */
4662 window_box_text_cols (w
)
4665 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4666 int width
= XINT (w
->total_cols
);
4668 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4669 /* Scroll bars occupy a few columns. */
4670 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4671 else if (!FRAME_WINDOW_P (f
)
4672 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4673 /* The column of `|' characters separating side-by-side windows
4674 occupies one column only. */
4677 if (FRAME_WINDOW_P (f
))
4678 /* On window-systems, fringes and display margins cannot be
4679 used for normal text. */
4680 width
-= (WINDOW_FRINGE_COLS (w
)
4681 + WINDOW_LEFT_MARGIN_COLS (w
)
4682 + WINDOW_RIGHT_MARGIN_COLS (w
));
4688 /************************************************************************
4690 ***********************************************************************/
4692 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4693 N screen-fulls, which is defined as the height of the window minus
4694 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4695 instead. Negative values of N mean scroll down. NOERROR non-zero
4696 means don't signal an error if we try to move over BEGV or ZV,
4700 window_scroll (window
, n
, whole
, noerror
)
4708 /* If we must, use the pixel-based version which is much slower than
4709 the line-based one but can handle varying line heights. */
4710 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4711 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4713 window_scroll_line_based (window
, n
, whole
, noerror
);
4719 /* Implementation of window_scroll that works based on pixel line
4720 heights. See the comment of window_scroll for parameter
4724 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4731 struct window
*w
= XWINDOW (window
);
4732 struct text_pos start
;
4733 int this_scroll_margin
;
4734 /* True if we fiddled the window vscroll field without really scrolling. */
4736 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4738 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4740 /* If PT is not visible in WINDOW, move back one half of
4741 the screen. Allow PT to be partially visible, otherwise
4742 something like (scroll-down 1) with PT in the line before
4743 the partially visible one would recenter. */
4745 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4747 /* Move backward half the height of the window. Performance note:
4748 vmotion used here is about 10% faster, but would give wrong
4749 results for variable height lines. */
4750 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4751 it
.current_y
= it
.last_visible_y
;
4752 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4754 /* The function move_iterator_vertically may move over more than
4755 the specified y-distance. If it->w is small, e.g. a
4756 mini-buffer window, we may end up in front of the window's
4757 display area. This is the case when Start displaying at the
4758 start of the line containing PT in this case. */
4759 if (it
.current_y
<= 0)
4761 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4762 move_it_vertically_backward (&it
, 0);
4766 start
= it
.current
.pos
;
4768 else if (auto_window_vscroll_p
)
4770 if (rtop
|| rbot
) /* partially visible */
4773 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4775 dy
= max ((window_box_height (w
)
4776 - next_screen_context_lines
* dy
),
4782 /* Only vscroll backwards if already vscrolled forwards. */
4783 if (w
->vscroll
< 0 && rtop
> 0)
4785 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4786 Fset_window_vscroll (window
, make_number (px
), Qt
);
4792 /* Do vscroll if already vscrolled or only display line. */
4793 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4795 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4796 Fset_window_vscroll (window
, make_number (px
), Qt
);
4800 /* Maybe modify window start instead of scrolling. */
4801 if (rbot
> 0 || w
->vscroll
< 0)
4805 Fset_window_vscroll (window
, make_number (0), Qt
);
4806 /* If there are other text lines above the current row,
4807 move window start to current row. Else to next row. */
4809 spos
= XINT (Fline_beginning_position (Qnil
));
4811 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4812 set_marker_restricted (w
->start
, make_number (spos
),
4814 w
->start_at_line_beg
= Qt
;
4815 w
->update_mode_line
= Qt
;
4816 XSETFASTINT (w
->last_modified
, 0);
4817 XSETFASTINT (w
->last_overlay_modified
, 0);
4818 /* Set force_start so that redisplay_window will run the
4819 window-scroll-functions. */
4820 w
->force_start
= Qt
;
4825 /* Cancel previous vscroll. */
4826 Fset_window_vscroll (window
, make_number (0), Qt
);
4829 /* If scroll_preserve_screen_position is non-nil, we try to set
4830 point in the same window line as it is now, so get that line. */
4831 if (!NILP (Vscroll_preserve_screen_position
))
4833 /* We preserve the goal pixel coordinate across consecutive
4834 calls to scroll-up or scroll-down. This avoids the
4835 possibility of point becoming "stuck" on a tall line when
4836 scrolling by one line. */
4837 if (window_scroll_pixel_based_preserve_y
< 0
4838 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
4839 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
4841 start_display (&it
, w
, start
);
4842 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4843 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4844 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4848 window_scroll_pixel_based_preserve_y
4849 = window_scroll_pixel_based_preserve_x
= -1;
4851 /* Move iterator it from start the specified distance forward or
4852 backward. The result is the new window start. */
4853 start_display (&it
, w
, start
);
4856 int start_pos
= IT_CHARPOS (it
);
4857 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4858 dy
= max ((window_box_height (w
)
4859 - next_screen_context_lines
* dy
),
4862 /* Note that move_it_vertically always moves the iterator to the
4863 start of a line. So, if the last line doesn't have a newline,
4864 we would end up at the start of the line ending at ZV. */
4867 move_it_vertically_backward (&it
, -dy
);
4868 /* Ensure we actually do move, e.g. in case we are currently
4869 looking at an image that is taller that the window height. */
4870 while (start_pos
== IT_CHARPOS (it
)
4871 && start_pos
> BEGV
)
4872 move_it_by_lines (&it
, -1, 1);
4876 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4877 MOVE_TO_POS
| MOVE_TO_Y
);
4878 /* Ensure we actually do move, e.g. in case we are currently
4879 looking at an image that is taller that the window height. */
4880 while (start_pos
== IT_CHARPOS (it
)
4882 move_it_by_lines (&it
, 1, 1);
4886 move_it_by_lines (&it
, n
, 1);
4888 /* We failed if we find ZV is already on the screen (scrolling up,
4889 means there's nothing past the end), or if we can't start any
4890 earlier (scrolling down, means there's nothing past the top). */
4891 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4892 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4894 if (IT_CHARPOS (it
) == ZV
)
4896 if (it
.current_y
< it
.last_visible_y
4897 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4898 > it
.last_visible_y
))
4900 /* The last line was only partially visible, make it fully
4902 w
->vscroll
= (it
.last_visible_y
4903 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4904 adjust_glyphs (it
.f
);
4908 else if (n
< 0) /* could happen with empty buffers */
4909 xsignal0 (Qbeginning_of_buffer
);
4911 xsignal0 (Qend_of_buffer
);
4915 if (w
->vscroll
!= 0)
4916 /* The first line was only partially visible, make it fully
4922 xsignal0 (Qbeginning_of_buffer
);
4925 /* If control gets here, then we vscrolled. */
4927 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4929 /* Don't try to change the window start below. */
4935 int pos
= IT_CHARPOS (it
);
4938 /* If in the middle of a multi-glyph character move forward to
4939 the next character. */
4940 if (in_display_vector_p (&it
))
4943 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4946 /* Set the window start, and set up the window for redisplay. */
4947 set_marker_restricted (w
->start
, make_number (pos
),
4949 bytepos
= XMARKER (w
->start
)->bytepos
;
4950 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4952 w
->update_mode_line
= Qt
;
4953 XSETFASTINT (w
->last_modified
, 0);
4954 XSETFASTINT (w
->last_overlay_modified
, 0);
4955 /* Set force_start so that redisplay_window will run the
4956 window-scroll-functions. */
4957 w
->force_start
= Qt
;
4960 /* The rest of this function uses current_y in a nonstandard way,
4961 not including the height of the header line if any. */
4962 it
.current_y
= it
.vpos
= 0;
4964 /* Move PT out of scroll margins.
4965 This code wants current_y to be zero at the window start position
4966 even if there is a header line. */
4967 this_scroll_margin
= max (0, scroll_margin
);
4968 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4969 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4973 /* We moved the window start towards ZV, so PT may be now
4974 in the scroll margin at the top. */
4975 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4976 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4977 && (NILP (Vscroll_preserve_screen_position
)
4978 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4979 /* We found PT at a legitimate height. Leave it alone. */
4981 else if (window_scroll_pixel_based_preserve_y
>= 0)
4983 /* If we have a header line, take account of it.
4984 This is necessary because we set it.current_y to 0, above. */
4985 move_it_to (&it
, -1,
4986 window_scroll_pixel_based_preserve_x
,
4987 window_scroll_pixel_based_preserve_y
4988 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4989 -1, MOVE_TO_Y
| MOVE_TO_X
);
4990 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4994 while (it
.current_y
< this_scroll_margin
)
4996 int prev
= it
.current_y
;
4997 move_it_by_lines (&it
, 1, 1);
4998 if (prev
== it
.current_y
)
5001 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5006 int charpos
, bytepos
;
5009 /* Save our position, for the
5010 window_scroll_pixel_based_preserve_y case. */
5011 charpos
= IT_CHARPOS (it
);
5012 bytepos
= IT_BYTEPOS (it
);
5014 /* We moved the window start towards BEGV, so PT may be now
5015 in the scroll margin at the bottom. */
5016 move_it_to (&it
, PT
, -1,
5017 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5018 - this_scroll_margin
- 1),
5020 MOVE_TO_POS
| MOVE_TO_Y
);
5022 /* Save our position, in case it's correct. */
5023 charpos
= IT_CHARPOS (it
);
5024 bytepos
= IT_BYTEPOS (it
);
5026 /* See if point is on a partially visible line at the end. */
5027 if (it
.what
== IT_EOB
)
5028 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5031 move_it_by_lines (&it
, 1, 1);
5032 partial_p
= it
.current_y
> it
.last_visible_y
;
5035 if (charpos
== PT
&& !partial_p
5036 && (NILP (Vscroll_preserve_screen_position
)
5037 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5038 /* We found PT before we found the display margin, so PT is ok. */
5040 else if (window_scroll_pixel_based_preserve_y
>= 0)
5042 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5043 start_display (&it
, w
, start
);
5044 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5045 here because we called start_display again and did not
5046 alter it.current_y this time. */
5047 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
5048 window_scroll_pixel_based_preserve_y
, -1,
5049 MOVE_TO_Y
| MOVE_TO_X
);
5050 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5055 /* The last line was only partially visible, so back up two
5056 lines to make sure we're on a fully visible line. */
5058 move_it_by_lines (&it
, -2, 0);
5059 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5062 /* No, the position we saved is OK, so use it. */
5063 SET_PT_BOTH (charpos
, bytepos
);
5069 /* Implementation of window_scroll that works based on screen lines.
5070 See the comment of window_scroll for parameter descriptions. */
5073 window_scroll_line_based (window
, n
, whole
, noerror
)
5079 register struct window
*w
= XWINDOW (window
);
5080 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5081 register int pos
, pos_byte
;
5082 register int ht
= window_internal_height (w
);
5083 register Lisp_Object tem
;
5087 Lisp_Object original_pos
= Qnil
;
5089 /* If scrolling screen-fulls, compute the number of lines to
5090 scroll from the window's height. */
5092 n
*= max (1, ht
- next_screen_context_lines
);
5094 startpos
= marker_position (w
->start
);
5096 if (!NILP (Vscroll_preserve_screen_position
))
5098 if (window_scroll_preserve_vpos
<= 0
5099 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5100 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5102 struct position posit
5103 = *compute_motion (startpos
, 0, 0, 0,
5105 -1, XINT (w
->hscroll
),
5107 window_scroll_preserve_vpos
= posit
.vpos
;
5108 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
5111 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
5112 make_number (window_scroll_preserve_vpos
));
5115 XSETFASTINT (tem
, PT
);
5116 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5120 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5125 lose
= n
< 0 && PT
== BEGV
;
5126 Fvertical_motion (make_number (n
), window
);
5130 SET_PT_BOTH (opoint
, opoint_byte
);
5137 xsignal0 (Qbeginning_of_buffer
);
5142 int this_scroll_margin
= scroll_margin
;
5144 /* Don't use a scroll margin that is negative or too large. */
5145 if (this_scroll_margin
< 0)
5146 this_scroll_margin
= 0;
5148 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5149 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5151 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5152 w
->start_at_line_beg
= bolp
;
5153 w
->update_mode_line
= Qt
;
5154 XSETFASTINT (w
->last_modified
, 0);
5155 XSETFASTINT (w
->last_overlay_modified
, 0);
5156 /* Set force_start so that redisplay_window will run
5157 the window-scroll-functions. */
5158 w
->force_start
= Qt
;
5160 if (!NILP (Vscroll_preserve_screen_position
)
5161 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5163 SET_PT_BOTH (pos
, pos_byte
);
5164 Fvertical_motion (original_pos
, window
);
5166 /* If we scrolled forward, put point enough lines down
5167 that it is outside the scroll margin. */
5172 if (this_scroll_margin
> 0)
5174 SET_PT_BOTH (pos
, pos_byte
);
5175 Fvertical_motion (make_number (this_scroll_margin
), window
);
5181 if (top_margin
<= opoint
)
5182 SET_PT_BOTH (opoint
, opoint_byte
);
5183 else if (!NILP (Vscroll_preserve_screen_position
))
5185 SET_PT_BOTH (pos
, pos_byte
);
5186 Fvertical_motion (original_pos
, window
);
5189 SET_PT (top_margin
);
5195 /* If we scrolled backward, put point near the end of the window
5196 but not within the scroll margin. */
5197 SET_PT_BOTH (pos
, pos_byte
);
5198 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5199 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5202 bottom_margin
= PT
+ 1;
5204 if (bottom_margin
> opoint
)
5205 SET_PT_BOTH (opoint
, opoint_byte
);
5208 if (!NILP (Vscroll_preserve_screen_position
))
5210 SET_PT_BOTH (pos
, pos_byte
);
5211 Fvertical_motion (original_pos
, window
);
5214 Fvertical_motion (make_number (-1), window
);
5223 xsignal0 (Qend_of_buffer
);
5228 /* Scroll selected_window up or down. If N is nil, scroll a
5229 screen-full which is defined as the height of the window minus
5230 next_screen_context_lines. If N is the symbol `-', scroll.
5231 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5232 up. This is the guts of Fscroll_up and Fscroll_down. */
5235 scroll_command (n
, direction
)
5239 int count
= SPECPDL_INDEX ();
5241 xassert (eabs (direction
) == 1);
5243 /* If selected window's buffer isn't current, make it current for
5244 the moment. But don't screw up if window_scroll gets an error. */
5245 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5247 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5248 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5250 /* Make redisplay consider other windows than just selected_window. */
5251 ++windows_or_buffers_changed
;
5255 window_scroll (selected_window
, direction
, 1, 0);
5256 else if (EQ (n
, Qminus
))
5257 window_scroll (selected_window
, -direction
, 1, 0);
5260 n
= Fprefix_numeric_value (n
);
5261 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5264 unbind_to (count
, Qnil
);
5267 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
5268 doc
: /* Scroll text of current window upward ARG lines.
5269 If ARG is omitted or nil, scroll upward by a near full screen.
5270 A near full screen is `next-screen-context-lines' less than a full screen.
5271 Negative ARG means scroll downward.
5272 If ARG is the atom `-', scroll downward by nearly full screen.
5273 When calling from a program, supply as argument a number, nil, or `-'. */)
5277 scroll_command (arg
, 1);
5281 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
5282 doc
: /* Scroll text of current window down ARG lines.
5283 If ARG is omitted or nil, scroll down by a near full screen.
5284 A near full screen is `next-screen-context-lines' less than a full screen.
5285 Negative ARG means scroll upward.
5286 If ARG is the atom `-', scroll upward by nearly full screen.
5287 When calling from a program, supply as argument a number, nil, or `-'. */)
5291 scroll_command (arg
, -1);
5295 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5296 doc
: /* Return the other window for \"other window scroll\" commands.
5297 If `other-window-scroll-buffer' is non-nil, a window
5298 showing that buffer is used.
5299 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5300 specifies the window. This takes precedence over
5301 `other-window-scroll-buffer'. */)
5306 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5307 && !NILP (Vminibuf_scroll_window
))
5308 window
= Vminibuf_scroll_window
;
5309 /* If buffer is specified, scroll that buffer. */
5310 else if (!NILP (Vother_window_scroll_buffer
))
5312 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5314 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5318 /* Nothing specified; look for a neighboring window on the same
5320 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5322 if (EQ (window
, selected_window
))
5323 /* That didn't get us anywhere; look for a window on another
5326 window
= Fnext_window (window
, Qnil
, Qt
);
5327 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5328 && ! EQ (window
, selected_window
));
5331 CHECK_LIVE_WINDOW (window
);
5333 if (EQ (window
, selected_window
))
5334 error ("There is no other window");
5339 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5340 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5341 A near full screen is `next-screen-context-lines' less than a full screen.
5342 The next window is the one below the current one; or the one at the top
5343 if the current one is at the bottom. Negative ARG means scroll downward.
5344 If ARG is the atom `-', scroll downward by nearly full screen.
5345 When calling from a program, supply as argument a number, nil, or `-'.
5347 If `other-window-scroll-buffer' is non-nil, scroll the window
5348 showing that buffer, popping the buffer up if necessary.
5349 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5350 specifies the window to scroll. This takes precedence over
5351 `other-window-scroll-buffer'. */)
5357 int count
= SPECPDL_INDEX ();
5359 window
= Fother_window_for_scrolling ();
5360 w
= XWINDOW (window
);
5362 /* Don't screw up if window_scroll gets an error. */
5363 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5364 ++windows_or_buffers_changed
;
5366 Fset_buffer (w
->buffer
);
5367 SET_PT (marker_position (w
->pointm
));
5370 window_scroll (window
, 1, 1, 1);
5371 else if (EQ (arg
, Qminus
))
5372 window_scroll (window
, -1, 1, 1);
5378 window_scroll (window
, XINT (arg
), 0, 1);
5381 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5382 unbind_to (count
, Qnil
);
5387 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5388 doc
: /* Scroll selected window display ARG columns left.
5389 Default for ARG is window width minus 2.
5390 Value is the total amount of leftward horizontal scrolling in
5391 effect after the change.
5392 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5393 lower bound for automatic scrolling, i.e. automatic scrolling
5394 will not scroll a window to a column less than the value returned
5395 by this function. This happens in an interactive call. */)
5397 register Lisp_Object arg
, set_minimum
;
5401 struct window
*w
= XWINDOW (selected_window
);
5404 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5406 arg
= Fprefix_numeric_value (arg
);
5408 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5409 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5411 if (!NILP (set_minimum
))
5412 w
->min_hscroll
= w
->hscroll
;
5417 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5418 doc
: /* Scroll selected window display ARG columns right.
5419 Default for ARG is window width minus 2.
5420 Value is the total amount of leftward horizontal scrolling in
5421 effect after the change.
5422 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5423 lower bound for automatic scrolling, i.e. automatic scrolling
5424 will not scroll a window to a column less than the value returned
5425 by this function. This happens in an interactive call. */)
5427 register Lisp_Object arg
, set_minimum
;
5431 struct window
*w
= XWINDOW (selected_window
);
5434 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5436 arg
= Fprefix_numeric_value (arg
);
5438 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5439 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5441 if (!NILP (set_minimum
))
5442 w
->min_hscroll
= w
->hscroll
;
5447 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5448 doc
: /* Return the window which was selected when entering the minibuffer.
5449 Returns nil, if current window is not a minibuffer window. */)
5452 if (minibuf_level
> 0
5453 && MINI_WINDOW_P (XWINDOW (selected_window
))
5454 && WINDOW_LIVE_P (minibuf_selected_window
))
5455 return minibuf_selected_window
;
5460 /* Value is the number of lines actually displayed in window W,
5461 as opposed to its height. */
5464 displayed_window_lines (w
)
5468 struct text_pos start
;
5469 int height
= window_box_height (w
);
5470 struct buffer
*old_buffer
;
5473 if (XBUFFER (w
->buffer
) != current_buffer
)
5475 old_buffer
= current_buffer
;
5476 set_buffer_internal (XBUFFER (w
->buffer
));
5481 /* In case W->start is out of the accessible range, do something
5482 reasonable. This happens in Info mode when Info-scroll-down
5483 calls (recenter -1) while W->start is 1. */
5484 if (XMARKER (w
->start
)->charpos
< BEGV
)
5485 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5486 else if (XMARKER (w
->start
)->charpos
> ZV
)
5487 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5489 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5491 start_display (&it
, w
, start
);
5492 move_it_vertically (&it
, height
);
5493 bottom_y
= line_bottom_y (&it
);
5495 /* rms: On a non-window display,
5496 the value of it.vpos at the bottom of the screen
5497 seems to be 1 larger than window_box_height (w).
5498 This kludge fixes a bug whereby (move-to-window-line -1)
5499 when ZV is on the last screen line
5500 moves to the previous screen line instead of the last one. */
5501 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5504 /* Add in empty lines at the bottom of the window. */
5505 if (bottom_y
< height
)
5507 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5508 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5512 set_buffer_internal (old_buffer
);
5518 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5519 doc
: /* Center point in window and redisplay frame.
5520 With prefix argument ARG, recenter putting point on screen line ARG
5521 relative to the current window. If ARG is negative, it counts up from the
5522 bottom of the window. (ARG should be less than the height of the window.)
5524 If ARG is omitted or nil, erase the entire frame and then redraw with point
5525 in the center of the current window. If `auto-resize-tool-bars' is set to
5526 `grow-only', this resets the tool-bar's height to the minimum height needed.
5528 Just C-u as prefix means put point in the center of the window
5529 and redisplay normally--don't erase and redraw the frame. */)
5531 register Lisp_Object arg
;
5533 struct window
*w
= XWINDOW (selected_window
);
5534 struct buffer
*buf
= XBUFFER (w
->buffer
);
5535 struct buffer
*obuf
= current_buffer
;
5537 int charpos
, bytepos
;
5539 int this_scroll_margin
;
5541 /* If redisplay is suppressed due to an error, try again. */
5542 obuf
->display_error_modiff
= 0;
5548 /* Invalidate pixel data calculated for all compositions. */
5549 for (i
= 0; i
< n_compositions
; i
++)
5550 composition_table
[i
]->font
= NULL
;
5552 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5554 Fredraw_frame (WINDOW_FRAME (w
));
5555 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5558 else if (CONSP (arg
)) /* Just C-u. */
5562 arg
= Fprefix_numeric_value (arg
);
5567 set_buffer_internal (buf
);
5569 /* Do this after making BUF current
5570 in case scroll_margin is buffer-local. */
5571 this_scroll_margin
= max (0, scroll_margin
);
5572 this_scroll_margin
= min (this_scroll_margin
,
5573 XFASTINT (w
->total_lines
) / 4);
5575 /* Handle centering on a graphical frame specially. Such frames can
5576 have variable-height lines and centering point on the basis of
5577 line counts would lead to strange effects. */
5578 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5585 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5586 start_display (&it
, w
, pt
);
5587 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5588 charpos
= IT_CHARPOS (it
);
5589 bytepos
= IT_BYTEPOS (it
);
5596 int extra_line_spacing
;
5597 int h
= window_box_height (w
);
5599 iarg
= - max (-iarg
, this_scroll_margin
);
5601 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5602 start_display (&it
, w
, pt
);
5604 /* Be sure we have the exact height of the full line containing PT. */
5605 move_it_by_lines (&it
, 0, 1);
5607 /* The amount of pixels we have to move back is the window
5608 height minus what's displayed in the line containing PT,
5609 and the lines below. */
5612 move_it_by_lines (&it
, nlines
, 1);
5614 if (it
.vpos
== nlines
)
5618 /* Last line has no newline */
5619 h
-= line_bottom_y (&it
);
5623 /* Don't reserve space for extra line spacing of last line. */
5624 extra_line_spacing
= it
.max_extra_line_spacing
;
5626 /* If we can't move down NLINES lines because we hit
5627 the end of the buffer, count in some empty lines. */
5628 if (it
.vpos
< nlines
)
5631 extra_line_spacing
= it
.extra_line_spacing
;
5632 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5637 /* Now find the new top line (starting position) of the window. */
5638 start_display (&it
, w
, pt
);
5640 move_it_vertically_backward (&it
, h
);
5642 /* If extra line spacing is present, we may move too far
5643 back. This causes the last line to be only partially
5644 visible (which triggers redisplay to recenter that line
5645 in the middle), so move forward.
5646 But ignore extra line spacing on last line, as it is not
5647 considered to be part of the visible height of the line.
5649 h
+= extra_line_spacing
;
5650 while (-it
.current_y
> h
)
5651 move_it_by_lines (&it
, 1, 1);
5653 charpos
= IT_CHARPOS (it
);
5654 bytepos
= IT_BYTEPOS (it
);
5658 struct position pos
;
5660 iarg
= max (iarg
, this_scroll_margin
);
5662 pos
= *vmotion (PT
, -iarg
, w
);
5663 charpos
= pos
.bufpos
;
5664 bytepos
= pos
.bytepos
;
5669 struct position pos
;
5670 int ht
= window_internal_height (w
);
5677 /* Don't let it get into the margin at either top or bottom. */
5678 iarg
= max (iarg
, this_scroll_margin
);
5679 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5681 pos
= *vmotion (PT
, - iarg
, w
);
5682 charpos
= pos
.bufpos
;
5683 bytepos
= pos
.bytepos
;
5686 /* Set the new window start. */
5687 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5688 w
->window_end_valid
= Qnil
;
5690 w
->optional_new_start
= Qt
;
5692 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5693 w
->start_at_line_beg
= Qt
;
5695 w
->start_at_line_beg
= Qnil
;
5697 set_buffer_internal (obuf
);
5702 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5704 doc
: /* Return the height in lines of the text display area of WINDOW.
5705 WINDOW defaults to the selected window.
5706 This doesn't include the mode-line (or header-line if any) or any
5707 partial-height lines in the text display area. */)
5711 struct window
*w
= decode_window (window
);
5712 int pixel_height
= window_box_height (w
);
5713 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5714 return make_number (line_height
);
5719 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5721 doc
: /* Position point relative to window.
5722 With no argument, position point at center of window.
5723 An argument specifies vertical position within the window;
5724 zero means top of window, negative means relative to bottom of window. */)
5728 struct window
*w
= XWINDOW (selected_window
);
5732 int this_scroll_margin
;
5735 window
= selected_window
;
5736 start
= marker_position (w
->start
);
5737 if (start
< BEGV
|| start
> ZV
)
5739 int height
= window_internal_height (w
);
5740 Fvertical_motion (make_number (- (height
/ 2)), window
);
5741 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5742 w
->start_at_line_beg
= Fbolp ();
5743 w
->force_start
= Qt
;
5746 Fgoto_char (w
->start
);
5748 lines
= displayed_window_lines (w
);
5751 this_scroll_margin
= max (0, scroll_margin
);
5752 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5756 XSETFASTINT (arg
, lines
/ 2);
5759 int iarg
= XINT (Fprefix_numeric_value (arg
));
5762 iarg
= iarg
+ lines
;
5764 #if 0 /* This code would prevent move-to-window-line from moving point
5765 to a place inside the scroll margins (which would cause the
5766 next redisplay to scroll). I wrote this code, but then concluded
5767 it is probably better not to install it. However, it is here
5768 inside #if 0 so as not to lose it. -- rms. */
5770 /* Don't let it get into the margin at either top or bottom. */
5771 iarg
= max (iarg
, this_scroll_margin
);
5772 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5775 arg
= make_number (iarg
);
5778 /* Skip past a partially visible first line. */
5780 XSETINT (arg
, XINT (arg
) + 1);
5782 return Fvertical_motion (arg
, window
);
5787 /***********************************************************************
5788 Window Configuration
5789 ***********************************************************************/
5791 struct save_window_data
5794 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5795 Lisp_Object selected_frame
;
5796 Lisp_Object current_window
;
5797 Lisp_Object current_buffer
;
5798 Lisp_Object minibuf_scroll_window
;
5799 Lisp_Object minibuf_selected_window
;
5800 Lisp_Object root_window
;
5801 Lisp_Object focus_frame
;
5802 /* A vector, each of whose elements is a struct saved_window
5804 Lisp_Object saved_windows
;
5806 /* All fields above are traced by the GC.
5807 From `fame-cols' down, the fields are ignored by the GC. */
5809 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5810 int frame_tool_bar_lines
;
5813 /* This is saved as a Lisp_Vector */
5816 /* these first two must agree with struct Lisp_Vector in lisp.h */
5818 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5821 Lisp_Object buffer
, start
, pointm
, mark
;
5822 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5823 Lisp_Object hscroll
, min_hscroll
;
5824 Lisp_Object parent
, prev
;
5825 Lisp_Object start_at_line_beg
;
5826 Lisp_Object display_table
;
5827 Lisp_Object orig_top_line
, orig_total_lines
;
5828 Lisp_Object left_margin_cols
, right_margin_cols
;
5829 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5830 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5831 Lisp_Object dedicated
, resize_proportionally
;
5834 #define SAVED_WINDOW_N(swv,n) \
5835 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5837 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5838 doc
: /* Return t if OBJECT is a window-configuration object. */)
5842 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5845 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5846 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5850 register struct save_window_data
*data
;
5851 struct Lisp_Vector
*saved_windows
;
5853 CHECK_WINDOW_CONFIGURATION (config
);
5855 data
= (struct save_window_data
*) XVECTOR (config
);
5856 saved_windows
= XVECTOR (data
->saved_windows
);
5857 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5860 DEFUN ("set-window-configuration", Fset_window_configuration
,
5861 Sset_window_configuration
, 1, 1, 0,
5862 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5863 CONFIGURATION must be a value previously returned
5864 by `current-window-configuration' (which see).
5865 If CONFIGURATION was made from a frame that is now deleted,
5866 only frame-independent values can be restored. In this case,
5867 the return value is nil. Otherwise the value is t. */)
5869 Lisp_Object configuration
;
5871 register struct save_window_data
*data
;
5872 struct Lisp_Vector
*saved_windows
;
5873 Lisp_Object new_current_buffer
;
5878 CHECK_WINDOW_CONFIGURATION (configuration
);
5880 data
= (struct save_window_data
*) XVECTOR (configuration
);
5881 saved_windows
= XVECTOR (data
->saved_windows
);
5883 new_current_buffer
= data
->current_buffer
;
5884 if (NILP (XBUFFER (new_current_buffer
)->name
))
5885 new_current_buffer
= Qnil
;
5888 if (XBUFFER (new_current_buffer
) == current_buffer
)
5889 /* The code further down "preserves point" by saving here PT in
5890 old_point and then setting it later back into PT. When the
5891 current-selected-window and the final-selected-window both show
5892 the current buffer, this suffers from the problem that the
5893 current PT is the window-point of the current-selected-window,
5894 while the final PT is the point of the final-selected-window, so
5895 this copy from one PT to the other would end up moving the
5896 window-point of the final-selected-window to the window-point of
5897 the current-selected-window. So we have to be careful which
5898 point of the current-buffer we copy into old_point. */
5899 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5900 && WINDOWP (selected_window
)
5901 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5902 && !EQ (selected_window
, data
->current_window
))
5903 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5907 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5908 point in new_current_buffer as of the last time this buffer was
5909 used. This can be non-deterministic since it can be changed by
5910 things like jit-lock by mere temporary selection of some random
5911 window that happens to show this buffer.
5912 So if possible we want this arbitrary choice of "which point" to
5913 be the one from the to-be-selected-window so as to prevent this
5914 window's cursor from being copied from another window. */
5915 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5916 /* If current_window = selected_window, its point is in BUF_PT. */
5917 && !EQ (selected_window
, data
->current_window
))
5918 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5920 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5923 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5926 /* If f is a dead frame, don't bother rebuilding its window tree.
5927 However, there is other stuff we should still try to do below. */
5928 if (FRAME_LIVE_P (f
))
5930 register struct window
*w
;
5931 register struct saved_window
*p
;
5932 struct window
*root_window
;
5933 struct window
**leaf_windows
;
5937 /* If the frame has been resized since this window configuration was
5938 made, we change the frame to the size specified in the
5939 configuration, restore the configuration, and then resize it
5940 back. We keep track of the prevailing height in these variables. */
5941 int previous_frame_lines
= FRAME_LINES (f
);
5942 int previous_frame_cols
= FRAME_COLS (f
);
5943 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5944 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5946 /* The mouse highlighting code could get screwed up
5947 if it runs during this. */
5950 if (data
->frame_lines
!= previous_frame_lines
5951 || data
->frame_cols
!= previous_frame_cols
)
5952 change_frame_size (f
, data
->frame_lines
,
5953 data
->frame_cols
, 0, 0, 0);
5954 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5955 if (data
->frame_menu_bar_lines
5956 != previous_frame_menu_bar_lines
)
5957 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5959 #ifdef HAVE_WINDOW_SYSTEM
5960 if (data
->frame_tool_bar_lines
5961 != previous_frame_tool_bar_lines
)
5962 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5967 /* "Swap out" point from the selected window's buffer
5968 into the window itself. (Normally the pointm of the selected
5969 window holds garbage.) We do this now, before
5970 restoring the window contents, and prevent it from
5971 being done later on when we select a new window. */
5972 if (! NILP (XWINDOW (selected_window
)->buffer
))
5974 w
= XWINDOW (selected_window
);
5975 set_marker_both (w
->pointm
,
5977 BUF_PT (XBUFFER (w
->buffer
)),
5978 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5981 windows_or_buffers_changed
++;
5982 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5984 /* Problem: Freeing all matrices and later allocating them again
5985 is a serious redisplay flickering problem. What we would
5986 really like to do is to free only those matrices not reused
5988 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5990 = (struct window
**) alloca (count_windows (root_window
)
5991 * sizeof (struct window
*));
5992 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5995 Mark all windows now on frame as "deleted".
5996 Restoring the new configuration "undeletes" any that are in it.
5998 Save their current buffers in their height fields, since we may
5999 need it later, if a buffer saved in the configuration is now
6001 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6003 for (k
= 0; k
< saved_windows
->size
; k
++)
6005 p
= SAVED_WINDOW_N (saved_windows
, k
);
6006 w
= XWINDOW (p
->window
);
6009 if (!NILP (p
->parent
))
6010 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6011 XFASTINT (p
->parent
))->window
;
6015 if (!NILP (p
->prev
))
6017 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6018 XFASTINT (p
->prev
))->window
;
6019 XWINDOW (w
->prev
)->next
= p
->window
;
6024 if (!NILP (w
->parent
))
6026 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6028 XWINDOW (w
->parent
)->vchild
= p
->window
;
6029 XWINDOW (w
->parent
)->hchild
= Qnil
;
6033 XWINDOW (w
->parent
)->hchild
= p
->window
;
6034 XWINDOW (w
->parent
)->vchild
= Qnil
;
6039 /* If we squirreled away the buffer in the window's height,
6041 if (BUFFERP (w
->total_lines
))
6042 w
->buffer
= w
->total_lines
;
6043 w
->left_col
= p
->left_col
;
6044 w
->top_line
= p
->top_line
;
6045 w
->total_cols
= p
->total_cols
;
6046 w
->total_lines
= p
->total_lines
;
6047 w
->hscroll
= p
->hscroll
;
6048 w
->min_hscroll
= p
->min_hscroll
;
6049 w
->display_table
= p
->display_table
;
6050 w
->orig_top_line
= p
->orig_top_line
;
6051 w
->orig_total_lines
= p
->orig_total_lines
;
6052 w
->left_margin_cols
= p
->left_margin_cols
;
6053 w
->right_margin_cols
= p
->right_margin_cols
;
6054 w
->left_fringe_width
= p
->left_fringe_width
;
6055 w
->right_fringe_width
= p
->right_fringe_width
;
6056 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6057 w
->scroll_bar_width
= p
->scroll_bar_width
;
6058 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6059 w
->dedicated
= p
->dedicated
;
6060 w
->resize_proportionally
= p
->resize_proportionally
;
6061 XSETFASTINT (w
->last_modified
, 0);
6062 XSETFASTINT (w
->last_overlay_modified
, 0);
6064 /* Reinstall the saved buffer and pointers into it. */
6065 if (NILP (p
->buffer
))
6066 w
->buffer
= p
->buffer
;
6069 if (!NILP (XBUFFER (p
->buffer
)->name
))
6070 /* If saved buffer is alive, install it. */
6072 w
->buffer
= p
->buffer
;
6073 w
->start_at_line_beg
= p
->start_at_line_beg
;
6074 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6075 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6076 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6077 p
->mark
, w
->buffer
);
6079 /* As documented in Fcurrent_window_configuration, don't
6080 restore the location of point in the buffer which was
6081 current when the window configuration was recorded. */
6082 if (!EQ (p
->buffer
, new_current_buffer
)
6083 && XBUFFER (p
->buffer
) == current_buffer
)
6084 Fgoto_char (w
->pointm
);
6086 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6087 /* Else unless window has a live buffer, get one. */
6089 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6090 /* This will set the markers to beginning of visible
6092 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6093 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6094 w
->start_at_line_beg
= Qt
;
6097 /* Keeping window's old buffer; make sure the markers
6100 /* Set window markers at start of visible range. */
6101 if (XMARKER (w
->start
)->buffer
== 0)
6102 set_marker_restricted (w
->start
, make_number (0),
6104 if (XMARKER (w
->pointm
)->buffer
== 0)
6105 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6106 BUF_PT (XBUFFER (w
->buffer
)),
6107 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6108 w
->start_at_line_beg
= Qt
;
6113 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6114 /* Prevent "swapping out point" in the old selected window
6115 using the buffer that has been restored into it.
6116 We already swapped out point that from that window's old buffer. */
6117 selected_window
= Qnil
;
6119 /* Arrange *not* to restore point in the buffer that was
6120 current when the window configuration was saved. */
6121 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6122 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6123 make_number (old_point
),
6124 XWINDOW (data
->current_window
)->buffer
);
6126 Fselect_window (data
->current_window
, Qnil
);
6127 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6130 if (NILP (data
->focus_frame
)
6131 || (FRAMEP (data
->focus_frame
)
6132 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6133 Fredirect_frame_focus (frame
, data
->focus_frame
);
6135 #if 0 /* I don't understand why this is needed, and it causes problems
6136 when the frame's old selected window has been deleted. */
6137 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6138 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6142 /* Set the screen height to the value it had before this function. */
6143 if (previous_frame_lines
!= FRAME_LINES (f
)
6144 || previous_frame_cols
!= FRAME_COLS (f
))
6145 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6147 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6148 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6149 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6151 #ifdef HAVE_WINDOW_SYSTEM
6152 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6153 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6158 /* Now, free glyph matrices in windows that were not reused. */
6159 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6161 if (NILP (leaf_windows
[i
]->buffer
))
6163 /* Assert it's not reused as a combination. */
6164 xassert (NILP (leaf_windows
[i
]->hchild
)
6165 && NILP (leaf_windows
[i
]->vchild
));
6166 free_window_matrices (leaf_windows
[i
]);
6168 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6176 /* Fselect_window will have made f the selected frame, so we
6177 reselect the proper frame here. Fhandle_switch_frame will change the
6178 selected window too, but that doesn't make the call to
6179 Fselect_window above totally superfluous; it still sets f's
6181 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6182 do_switch_frame (data
->selected_frame
, 0, 0);
6184 run_window_configuration_change_hook (f
);
6187 if (!NILP (new_current_buffer
))
6188 Fset_buffer (new_current_buffer
);
6190 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6191 minibuf_selected_window
= data
->minibuf_selected_window
;
6193 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6196 /* Mark all windows now on frame as deleted
6197 by setting their buffers to nil. */
6200 delete_all_subwindows (w
)
6201 register struct window
*w
;
6203 if (!NILP (w
->next
))
6204 delete_all_subwindows (XWINDOW (w
->next
));
6205 if (!NILP (w
->vchild
))
6206 delete_all_subwindows (XWINDOW (w
->vchild
));
6207 if (!NILP (w
->hchild
))
6208 delete_all_subwindows (XWINDOW (w
->hchild
));
6210 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6212 if (!NILP (w
->buffer
))
6215 /* We set all three of these fields to nil, to make sure that we can
6216 distinguish this dead window from any live window. Live leaf
6217 windows will have buffer set, and combination windows will have
6218 vchild or hchild set. */
6223 Vwindow_list
= Qnil
;
6227 count_windows (window
)
6228 register struct window
*window
;
6230 register int count
= 1;
6231 if (!NILP (window
->next
))
6232 count
+= count_windows (XWINDOW (window
->next
));
6233 if (!NILP (window
->vchild
))
6234 count
+= count_windows (XWINDOW (window
->vchild
));
6235 if (!NILP (window
->hchild
))
6236 count
+= count_windows (XWINDOW (window
->hchild
));
6241 /* Fill vector FLAT with leaf windows under W, starting at index I.
6242 Value is last index + 1. */
6245 get_leaf_windows (w
, flat
, i
)
6247 struct window
**flat
;
6252 if (!NILP (w
->hchild
))
6253 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6254 else if (!NILP (w
->vchild
))
6255 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6259 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6266 /* Return a pointer to the glyph W's physical cursor is on. Value is
6267 null if W's current matrix is invalid, so that no meaningfull glyph
6271 get_phys_cursor_glyph (w
)
6274 struct glyph_row
*row
;
6275 struct glyph
*glyph
;
6277 if (w
->phys_cursor
.vpos
>= 0
6278 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6279 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6281 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6282 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6291 save_window_save (window
, vector
, i
)
6293 struct Lisp_Vector
*vector
;
6296 register struct saved_window
*p
;
6297 register struct window
*w
;
6298 register Lisp_Object tem
;
6300 for (;!NILP (window
); window
= w
->next
)
6302 p
= SAVED_WINDOW_N (vector
, i
);
6303 w
= XWINDOW (window
);
6305 XSETFASTINT (w
->temslot
, i
); i
++;
6307 p
->buffer
= w
->buffer
;
6308 p
->left_col
= w
->left_col
;
6309 p
->top_line
= w
->top_line
;
6310 p
->total_cols
= w
->total_cols
;
6311 p
->total_lines
= w
->total_lines
;
6312 p
->hscroll
= w
->hscroll
;
6313 p
->min_hscroll
= w
->min_hscroll
;
6314 p
->display_table
= w
->display_table
;
6315 p
->orig_top_line
= w
->orig_top_line
;
6316 p
->orig_total_lines
= w
->orig_total_lines
;
6317 p
->left_margin_cols
= w
->left_margin_cols
;
6318 p
->right_margin_cols
= w
->right_margin_cols
;
6319 p
->left_fringe_width
= w
->left_fringe_width
;
6320 p
->right_fringe_width
= w
->right_fringe_width
;
6321 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6322 p
->scroll_bar_width
= w
->scroll_bar_width
;
6323 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6324 p
->dedicated
= w
->dedicated
;
6325 p
->resize_proportionally
= w
->resize_proportionally
;
6326 if (!NILP (w
->buffer
))
6328 /* Save w's value of point in the window configuration.
6329 If w is the selected window, then get the value of point
6330 from the buffer; pointm is garbage in the selected window. */
6331 if (EQ (window
, selected_window
))
6333 p
->pointm
= Fmake_marker ();
6334 set_marker_both (p
->pointm
, w
->buffer
,
6335 BUF_PT (XBUFFER (w
->buffer
)),
6336 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6339 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6341 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6342 p
->start_at_line_beg
= w
->start_at_line_beg
;
6344 tem
= XBUFFER (w
->buffer
)->mark
;
6345 p
->mark
= Fcopy_marker (tem
, Qnil
);
6352 p
->start_at_line_beg
= Qnil
;
6355 if (NILP (w
->parent
))
6358 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6363 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6365 if (!NILP (w
->vchild
))
6366 i
= save_window_save (w
->vchild
, vector
, i
);
6367 if (!NILP (w
->hchild
))
6368 i
= save_window_save (w
->hchild
, vector
, i
);
6374 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6375 Scurrent_window_configuration
, 0, 1, 0,
6376 doc
: /* Return an object representing the current window configuration of FRAME.
6377 If FRAME is nil or omitted, use the selected frame.
6378 This describes the number of windows, their sizes and current buffers,
6379 and for each displayed buffer, where display starts, and the positions of
6380 point and mark. An exception is made for point in the current buffer:
6381 its value is -not- saved.
6382 This also records the currently selected frame, and FRAME's focus
6383 redirection (see `redirect-frame-focus'). */)
6387 register Lisp_Object tem
;
6388 register int n_windows
;
6389 register struct save_window_data
*data
;
6394 frame
= selected_frame
;
6395 CHECK_LIVE_FRAME (frame
);
6398 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6399 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6400 PVEC_WINDOW_CONFIGURATION
);
6402 data
->frame_cols
= FRAME_COLS (f
);
6403 data
->frame_lines
= FRAME_LINES (f
);
6404 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6405 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6406 data
->selected_frame
= selected_frame
;
6407 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6408 XSETBUFFER (data
->current_buffer
, current_buffer
);
6409 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6410 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6411 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6412 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6413 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6414 data
->saved_windows
= tem
;
6415 for (i
= 0; i
< n_windows
; i
++)
6416 XVECTOR (tem
)->contents
[i
]
6417 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6418 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6419 XSETWINDOW_CONFIGURATION (tem
, data
);
6423 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6425 doc
: /* Execute BODY, preserving window sizes and contents.
6426 Return the value of the last form in BODY.
6427 Restore which buffer appears in which window, where display starts,
6428 and the value of point and mark for each window.
6429 Also restore the choice of selected window.
6430 Also restore which buffer is current.
6431 Does not restore the value of point in current buffer.
6432 usage: (save-window-excursion BODY...) */)
6436 register Lisp_Object val
;
6437 register int count
= SPECPDL_INDEX ();
6439 record_unwind_protect (Fset_window_configuration
,
6440 Fcurrent_window_configuration (Qnil
));
6441 val
= Fprogn (args
);
6442 return unbind_to (count
, val
);
6447 /***********************************************************************
6449 ***********************************************************************/
6455 Lisp_Object tail
= Qnil
;
6456 Lisp_Object result
= Qnil
;
6463 if (!NILP (w
->hchild
))
6464 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6465 window_tree (XWINDOW (w
->hchild
))));
6466 else if (!NILP (w
->vchild
))
6467 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6468 window_tree (XWINDOW (w
->vchild
))));
6472 result
= tail
= Fcons (wn
, Qnil
);
6476 XSETCDR (tail
, Fcons (wn
, Qnil
));
6480 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6488 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6490 doc
: /* Return the window tree for frame FRAME.
6492 The return value is a list of the form (ROOT MINI), where ROOT
6493 represents the window tree of the frame's root window, and MINI
6494 is the frame's minibuffer window.
6496 If the root window is not split, ROOT is the root window itself.
6497 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6498 horizontal split, and t for a vertical split, EDGES gives the combined
6499 size and position of the subwindows in the split, and the rest of the
6500 elements are the subwindows in the split. Each of the subwindows may
6501 again be a window or a list representing a window split, and so on.
6502 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6504 If FRAME is nil or omitted, return information on the currently
6512 frame
= selected_frame
;
6514 CHECK_FRAME (frame
);
6517 if (!FRAME_LIVE_P (f
))
6520 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6524 /***********************************************************************
6526 ***********************************************************************/
6528 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6530 doc
: /* Set width of marginal areas of window WINDOW.
6531 If WINDOW is nil, set margins of the currently selected window.
6532 Second arg LEFT-WIDTH specifies the number of character cells to
6533 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6534 does the same for the right marginal area. A nil width parameter
6535 means no margin. */)
6536 (window
, left_width
, right_width
)
6537 Lisp_Object window
, left_width
, right_width
;
6539 struct window
*w
= decode_window (window
);
6541 /* Translate negative or zero widths to nil.
6542 Margins that are too wide have to be checked elsewhere. */
6544 if (!NILP (left_width
))
6546 CHECK_NUMBER (left_width
);
6547 if (XINT (left_width
) <= 0)
6551 if (!NILP (right_width
))
6553 CHECK_NUMBER (right_width
);
6554 if (XINT (right_width
) <= 0)
6558 if (!EQ (w
->left_margin_cols
, left_width
)
6559 || !EQ (w
->right_margin_cols
, right_width
))
6561 w
->left_margin_cols
= left_width
;
6562 w
->right_margin_cols
= right_width
;
6564 adjust_window_margins (w
);
6566 ++windows_or_buffers_changed
;
6567 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6574 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6576 doc
: /* Get width of marginal areas of window WINDOW.
6577 If WINDOW is omitted or nil, use the currently selected window.
6578 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6579 If a marginal area does not exist, its width will be returned
6584 struct window
*w
= decode_window (window
);
6585 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6590 /***********************************************************************
6592 ***********************************************************************/
6594 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6596 doc
: /* Set the fringe widths of window WINDOW.
6597 If WINDOW is nil, set the fringe widths of the currently selected
6599 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6600 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6601 fringe width. If a fringe width arg is nil, that means to use the
6602 frame's default fringe width. Default fringe widths can be set with
6603 the command `set-fringe-style'.
6604 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6605 outside of the display margins. By default, fringes are drawn between
6606 display marginal areas and the text area. */)
6607 (window
, left_width
, right_width
, outside_margins
)
6608 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6610 struct window
*w
= decode_window (window
);
6612 if (!NILP (left_width
))
6613 CHECK_NATNUM (left_width
);
6614 if (!NILP (right_width
))
6615 CHECK_NATNUM (right_width
);
6617 /* Do nothing on a tty. */
6618 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6619 && (!EQ (w
->left_fringe_width
, left_width
)
6620 || !EQ (w
->right_fringe_width
, right_width
)
6621 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6623 w
->left_fringe_width
= left_width
;
6624 w
->right_fringe_width
= right_width
;
6625 w
->fringes_outside_margins
= outside_margins
;
6627 adjust_window_margins (w
);
6629 clear_glyph_matrix (w
->current_matrix
);
6630 w
->window_end_valid
= Qnil
;
6632 ++windows_or_buffers_changed
;
6633 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6640 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6642 doc
: /* Get width of fringes of window WINDOW.
6643 If WINDOW is omitted or nil, use the currently selected window.
6644 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6648 struct window
*w
= decode_window (window
);
6650 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6651 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6652 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6653 ? Qt
: Qnil
), Qnil
)));
6658 /***********************************************************************
6660 ***********************************************************************/
6662 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6664 doc
: /* Set width and type of scroll bars of window WINDOW.
6665 If window is nil, set scroll bars of the currently selected window.
6666 Second parameter WIDTH specifies the pixel width for the scroll bar;
6667 this is automatically adjusted to a multiple of the frame column width.
6668 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6669 bar: left, right, or nil.
6670 If WIDTH is nil, use the frame's scroll-bar width.
6671 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6672 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6673 (window
, width
, vertical_type
, horizontal_type
)
6674 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6676 struct window
*w
= decode_window (window
);
6680 CHECK_NATNUM (width
);
6682 if (XINT (width
) == 0)
6683 vertical_type
= Qnil
;
6686 if (!(NILP (vertical_type
)
6687 || EQ (vertical_type
, Qleft
)
6688 || EQ (vertical_type
, Qright
)
6689 || EQ (vertical_type
, Qt
)))
6690 error ("Invalid type of vertical scroll bar");
6692 if (!EQ (w
->scroll_bar_width
, width
)
6693 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6695 w
->scroll_bar_width
= width
;
6696 w
->vertical_scroll_bar_type
= vertical_type
;
6698 adjust_window_margins (w
);
6700 clear_glyph_matrix (w
->current_matrix
);
6701 w
->window_end_valid
= Qnil
;
6703 ++windows_or_buffers_changed
;
6704 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6711 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6713 doc
: /* Get width and type of scroll bars of window WINDOW.
6714 If WINDOW is omitted or nil, use the currently selected window.
6715 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6716 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6721 struct window
*w
= decode_window (window
);
6722 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6723 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6724 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6725 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6726 Fcons (w
->vertical_scroll_bar_type
,
6727 Fcons (Qnil
, Qnil
))));
6732 /***********************************************************************
6734 ***********************************************************************/
6736 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6737 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6738 Use the selected window if WINDOW is nil or omitted.
6739 Normally, value is a multiple of the canonical character height of WINDOW;
6740 optional second arg PIXELS-P means value is measured in pixels. */)
6742 Lisp_Object window
, pixels_p
;
6749 window
= selected_window
;
6751 CHECK_WINDOW (window
);
6752 w
= XWINDOW (window
);
6753 f
= XFRAME (w
->frame
);
6755 if (FRAME_WINDOW_P (f
))
6756 result
= (NILP (pixels_p
)
6757 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6758 : make_number (-w
->vscroll
));
6760 result
= make_number (0);
6765 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6767 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6768 WINDOW nil means use the selected window. Normally, VSCROLL is a
6769 non-negative multiple of the canonical character height of WINDOW;
6770 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6771 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6772 corresponds to an integral number of pixels. The return value is the
6773 result of this rounding.
6774 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6775 (window
, vscroll
, pixels_p
)
6776 Lisp_Object window
, vscroll
, pixels_p
;
6782 window
= selected_window
;
6784 CHECK_WINDOW (window
);
6785 CHECK_NUMBER_OR_FLOAT (vscroll
);
6787 w
= XWINDOW (window
);
6788 f
= XFRAME (w
->frame
);
6790 if (FRAME_WINDOW_P (f
))
6792 int old_dy
= w
->vscroll
;
6794 w
->vscroll
= - (NILP (pixels_p
)
6795 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6796 : XFLOATINT (vscroll
));
6797 w
->vscroll
= min (w
->vscroll
, 0);
6799 if (w
->vscroll
!= old_dy
)
6801 /* Adjust glyph matrix of the frame if the virtual display
6802 area becomes larger than before. */
6803 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6806 /* Prevent redisplay shortcuts. */
6807 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6811 return Fwindow_vscroll (window
, pixels_p
);
6815 /* Call FN for all leaf windows on frame F. FN is called with the
6816 first argument being a pointer to the leaf window, and with
6817 additional argument USER_DATA. Stops when FN returns 0. */
6820 foreach_window (f
, fn
, user_data
)
6822 int (* fn
) P_ ((struct window
*, void *));
6825 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6826 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6827 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6831 /* Helper function for foreach_window. Call FN for all leaf windows
6832 reachable from W. FN is called with the first argument being a
6833 pointer to the leaf window, and with additional argument USER_DATA.
6834 Stop when FN returns 0. Value is 0 if stopped by FN. */
6837 foreach_window_1 (w
, fn
, user_data
)
6839 int (* fn
) P_ ((struct window
*, void *));
6844 for (cont
= 1; w
&& cont
;)
6846 if (!NILP (w
->hchild
))
6847 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6848 else if (!NILP (w
->vchild
))
6849 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6851 cont
= fn (w
, user_data
);
6853 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6860 /* Freeze or unfreeze the window start of W unless it is a
6861 mini-window or the selected window. FREEZE_P non-null means freeze
6862 the window start. */
6865 freeze_window_start (w
, freeze_p
)
6869 if (MINI_WINDOW_P (w
)
6870 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6871 && (w
== XWINDOW (selected_window
)
6872 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6873 && ! NILP (Vminibuf_scroll_window
)
6874 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6877 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6882 /* Freeze or unfreeze the window starts of all leaf windows on frame
6883 F, except the selected window and a mini-window. FREEZE_P non-zero
6884 means freeze the window start. */
6887 freeze_window_starts (f
, freeze_p
)
6891 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6895 /***********************************************************************
6897 ***********************************************************************/
6899 /* Return 1 if window configurations C1 and C2
6900 describe the same state of affairs. This is used by Fequal. */
6903 compare_window_configurations (c1
, c2
, ignore_positions
)
6905 int ignore_positions
;
6907 register struct save_window_data
*d1
, *d2
;
6908 struct Lisp_Vector
*sw1
, *sw2
;
6911 CHECK_WINDOW_CONFIGURATION (c1
);
6912 CHECK_WINDOW_CONFIGURATION (c2
);
6914 d1
= (struct save_window_data
*) XVECTOR (c1
);
6915 d2
= (struct save_window_data
*) XVECTOR (c2
);
6916 sw1
= XVECTOR (d1
->saved_windows
);
6917 sw2
= XVECTOR (d2
->saved_windows
);
6919 if (d1
->frame_cols
!= d2
->frame_cols
)
6921 if (d1
->frame_lines
!= d2
->frame_lines
)
6923 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
6925 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6927 /* Don't compare the current_window field directly.
6928 Instead see w1_is_current and w2_is_current, below. */
6929 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6931 if (! ignore_positions
)
6933 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6935 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6938 /* Don't compare the root_window field.
6939 We don't require the two configurations
6940 to use the same window object,
6941 and the two root windows must be equivalent
6942 if everything else compares equal. */
6943 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6946 /* Verify that the two confis have the same number of windows. */
6947 if (sw1
->size
!= sw2
->size
)
6950 for (i
= 0; i
< sw1
->size
; i
++)
6952 struct saved_window
*p1
, *p2
;
6953 int w1_is_current
, w2_is_current
;
6955 p1
= SAVED_WINDOW_N (sw1
, i
);
6956 p2
= SAVED_WINDOW_N (sw2
, i
);
6958 /* Verify that the current windows in the two
6959 configurations correspond to each other. */
6960 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6961 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6963 if (w1_is_current
!= w2_is_current
)
6966 /* Verify that the corresponding windows do match. */
6967 if (! EQ (p1
->buffer
, p2
->buffer
))
6969 if (! EQ (p1
->left_col
, p2
->left_col
))
6971 if (! EQ (p1
->top_line
, p2
->top_line
))
6973 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6975 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6977 if (! EQ (p1
->display_table
, p2
->display_table
))
6979 if (! EQ (p1
->parent
, p2
->parent
))
6981 if (! EQ (p1
->prev
, p2
->prev
))
6983 if (! ignore_positions
)
6985 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6987 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6989 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6991 if (NILP (Fequal (p1
->start
, p2
->start
)))
6993 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6995 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6998 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7000 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7002 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7004 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7006 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7008 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7010 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7017 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7018 Scompare_window_configurations
, 2, 2, 0,
7019 doc
: /* Compare two window configurations as regards the structure of windows.
7020 This function ignores details such as the values of point and mark
7021 and scrolling positions. */)
7025 if (compare_window_configurations (x
, y
, 1))
7033 struct frame
*f
= make_initial_frame ();
7034 XSETFRAME (selected_frame
, f
);
7035 Vterminal_frame
= selected_frame
;
7036 minibuf_window
= f
->minibuffer_window
;
7037 selected_window
= f
->selected_window
;
7038 last_nonminibuf_frame
= f
;
7040 window_initialized
= 1;
7046 Vwindow_list
= Qnil
;
7052 Qscroll_up
= intern ("scroll-up");
7053 staticpro (&Qscroll_up
);
7055 Qscroll_down
= intern ("scroll-down");
7056 staticpro (&Qscroll_down
);
7058 Qwindow_size_fixed
= intern ("window-size-fixed");
7059 staticpro (&Qwindow_size_fixed
);
7060 Fset (Qwindow_size_fixed
, Qnil
);
7062 staticpro (&Qwindow_configuration_change_hook
);
7063 Qwindow_configuration_change_hook
7064 = intern ("window-configuration-change-hook");
7066 Qwindowp
= intern ("windowp");
7067 staticpro (&Qwindowp
);
7069 Qwindow_configuration_p
= intern ("window-configuration-p");
7070 staticpro (&Qwindow_configuration_p
);
7072 Qwindow_live_p
= intern ("window-live-p");
7073 staticpro (&Qwindow_live_p
);
7075 Qdisplay_buffer
= intern ("display-buffer");
7076 staticpro (&Qdisplay_buffer
);
7078 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7079 staticpro (&Qtemp_buffer_show_hook
);
7081 staticpro (&Vwindow_list
);
7083 minibuf_selected_window
= Qnil
;
7084 staticpro (&minibuf_selected_window
);
7086 window_scroll_pixel_based_preserve_x
= -1;
7087 window_scroll_pixel_based_preserve_y
= -1;
7088 window_scroll_preserve_hpos
= -1;
7089 window_scroll_preserve_vpos
= -1;
7091 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7092 doc
: /* Non-nil means call as function to display a help buffer.
7093 The function is called with one argument, the buffer to be displayed.
7094 Used by `with-output-to-temp-buffer'.
7095 If this function is used, then it must do the entire job of showing
7096 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7097 Vtemp_buffer_show_function
= Qnil
;
7099 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7100 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7101 Vminibuf_scroll_window
= Qnil
;
7103 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7104 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7105 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7106 is displayed in the `mode-line' face. */);
7107 mode_line_in_non_selected_windows
= 1;
7109 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7110 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7111 Vother_window_scroll_buffer
= Qnil
;
7113 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7114 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7115 auto_window_vscroll_p
= 1;
7117 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7118 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7119 next_screen_context_lines
= 2;
7121 DEFVAR_INT ("window-min-height", &window_min_height
,
7122 doc
: /* Allow deleting windows less than this tall.
7123 The value is measured in line units. If a window wants a modeline it
7124 is counted as one line.
7126 Emacs honors settings of this variable when enlarging or shrinking
7127 windows vertically. A value less than 1 is invalid. */);
7128 window_min_height
= 4;
7130 DEFVAR_INT ("window-min-width", &window_min_width
,
7131 doc
: /* Allow deleting windows less than this wide.
7132 The value is measured in characters and includes any fringes or
7135 Emacs honors settings of this variable when enlarging or shrinking
7136 windows horizontally. A value less than 2 is invalid. */);
7137 window_min_width
= 10;
7139 DEFVAR_LISP ("scroll-preserve-screen-position",
7140 &Vscroll_preserve_screen_position
,
7141 doc
: /* *Controls if scroll commands move point to keep its screen position unchanged.
7142 A value of nil means point does not keep its screen position except
7143 at the scroll margin or window boundary respectively.
7144 A value of t means point keeps its screen position if the scroll
7145 command moved it vertically out of the window, e.g. when scrolling
7147 Any other value means point always keeps its screen position. */);
7148 Vscroll_preserve_screen_position
= Qnil
;
7150 DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type
,
7151 doc
: /* Type of marker to use for `window-point'. */);
7152 Vwindow_point_insertion_type
= Qnil
;
7154 DEFVAR_LISP ("window-configuration-change-hook",
7155 &Vwindow_configuration_change_hook
,
7156 doc
: /* Functions to call when window configuration changes.
7157 The buffer-local part is run once per window, with the relevant window
7158 selected; while the global part is run only once for the modified frame,
7159 with the relevant frame selected. */);
7160 Vwindow_configuration_change_hook
= Qnil
;
7162 defsubr (&Sselected_window
);
7163 defsubr (&Sminibuffer_window
);
7164 defsubr (&Swindow_minibuffer_p
);
7165 defsubr (&Swindowp
);
7166 defsubr (&Swindow_live_p
);
7167 defsubr (&Spos_visible_in_window_p
);
7168 defsubr (&Swindow_line_height
);
7169 defsubr (&Swindow_buffer
);
7170 defsubr (&Swindow_height
);
7171 defsubr (&Swindow_width
);
7172 defsubr (&Swindow_full_width_p
);
7173 defsubr (&Swindow_hscroll
);
7174 defsubr (&Sset_window_hscroll
);
7175 defsubr (&Swindow_redisplay_end_trigger
);
7176 defsubr (&Sset_window_redisplay_end_trigger
);
7177 defsubr (&Swindow_edges
);
7178 defsubr (&Swindow_pixel_edges
);
7179 defsubr (&Swindow_inside_edges
);
7180 defsubr (&Swindow_inside_pixel_edges
);
7181 defsubr (&Scoordinates_in_window_p
);
7182 defsubr (&Swindow_at
);
7183 defsubr (&Swindow_point
);
7184 defsubr (&Swindow_start
);
7185 defsubr (&Swindow_end
);
7186 defsubr (&Sset_window_point
);
7187 defsubr (&Sset_window_start
);
7188 defsubr (&Swindow_dedicated_p
);
7189 defsubr (&Sset_window_dedicated_p
);
7190 defsubr (&Swindow_display_table
);
7191 defsubr (&Sset_window_display_table
);
7192 defsubr (&Snext_window
);
7193 defsubr (&Sprevious_window
);
7194 defsubr (&Sother_window
);
7195 defsubr (&Sget_lru_window
);
7196 defsubr (&Sget_largest_window
);
7197 defsubr (&Sget_buffer_window
);
7198 defsubr (&Sdelete_other_windows
);
7199 defsubr (&Sdelete_windows_on
);
7200 defsubr (&Sreplace_buffer_in_windows
);
7201 defsubr (&Sdelete_window
);
7202 defsubr (&Sset_window_buffer
);
7203 defsubr (&Sselect_window
);
7204 defsubr (&Sforce_window_update
);
7205 defsubr (&Ssplit_window
);
7206 defsubr (&Senlarge_window
);
7207 defsubr (&Sshrink_window
);
7208 defsubr (&Sadjust_window_trailing_edge
);
7209 defsubr (&Sscroll_up
);
7210 defsubr (&Sscroll_down
);
7211 defsubr (&Sscroll_left
);
7212 defsubr (&Sscroll_right
);
7213 defsubr (&Sother_window_for_scrolling
);
7214 defsubr (&Sscroll_other_window
);
7215 defsubr (&Sminibuffer_selected_window
);
7216 defsubr (&Srecenter
);
7217 defsubr (&Swindow_text_height
);
7218 defsubr (&Smove_to_window_line
);
7219 defsubr (&Swindow_configuration_p
);
7220 defsubr (&Swindow_configuration_frame
);
7221 defsubr (&Sset_window_configuration
);
7222 defsubr (&Scurrent_window_configuration
);
7223 defsubr (&Ssave_window_excursion
);
7224 defsubr (&Swindow_tree
);
7225 defsubr (&Sset_window_margins
);
7226 defsubr (&Swindow_margins
);
7227 defsubr (&Sset_window_fringes
);
7228 defsubr (&Swindow_fringes
);
7229 defsubr (&Sset_window_scroll_bars
);
7230 defsubr (&Swindow_scroll_bars
);
7231 defsubr (&Swindow_vscroll
);
7232 defsubr (&Sset_window_vscroll
);
7233 defsubr (&Scompare_window_configurations
);
7234 defsubr (&Swindow_list
);
7235 defsubr (&Swindow_parameters
);
7236 defsubr (&Swindow_parameter
);
7237 defsubr (&Sset_window_parameter
);
7244 initial_define_key (control_x_map
, '1', "delete-other-windows");
7245 initial_define_key (control_x_map
, '2', "split-window");
7246 initial_define_key (control_x_map
, '0', "delete-window");
7247 initial_define_key (control_x_map
, 'o', "other-window");
7248 initial_define_key (control_x_map
, '^', "enlarge-window");
7249 initial_define_key (control_x_map
, '<', "scroll-left");
7250 initial_define_key (control_x_map
, '>', "scroll-right");
7252 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7253 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7254 initial_define_key (meta_map
, 'v', "scroll-down");
7256 initial_define_key (global_map
, Ctl('L'), "recenter");
7257 initial_define_key (meta_map
, 'r', "move-to-window-line");
7260 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7261 (do not change this comment) */