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
3500 do not put this buffer at the front of the list of recently selected ones.
3502 Note that the main editor command loop
3503 selects the buffer of the 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 ++window_select_count
;
3517 XSETFASTINT (w
->use_time
, window_select_count
);
3518 if (EQ (window
, selected_window
))
3521 sf
= SELECTED_FRAME ();
3522 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3524 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3525 /* Use this rather than Fhandle_switch_frame
3526 so that FRAME_FOCUS_FRAME is moved appropriately as we
3527 move around in the state where a minibuffer in a separate
3529 Fselect_frame (WINDOW_FRAME (w
));
3530 /* Fselect_frame called us back so we've done all the work already. */
3531 eassert (EQ (window
, selected_window
));
3535 sf
->selected_window
= window
;
3537 /* Store the current buffer's actual point into the
3538 old selected window. It belongs to that window,
3539 and when the window is not selected, must be in the window. */
3540 if (!NILP (selected_window
))
3542 ow
= XWINDOW (selected_window
);
3543 if (! NILP (ow
->buffer
))
3544 set_marker_both (ow
->pointm
, ow
->buffer
,
3545 BUF_PT (XBUFFER (ow
->buffer
)),
3546 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3549 selected_window
= window
;
3551 if (NILP (norecord
))
3552 record_buffer (w
->buffer
);
3553 Fset_buffer (w
->buffer
);
3555 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3557 /* Go to the point recorded in the window.
3558 This is important when the buffer is in more
3559 than one window. It also matters when
3560 redisplay_window has altered point after scrolling,
3561 because it makes the change only in the window. */
3563 register int new_point
= marker_position (w
->pointm
);
3564 if (new_point
< BEGV
)
3566 else if (new_point
> ZV
)
3572 windows_or_buffers_changed
++;
3577 select_window_norecord (window
)
3580 return Fselect_window (window
, Qt
);
3584 display_buffer (buffer
, not_this_window_p
, override_frame
)
3585 Lisp_Object buffer
, not_this_window_p
, override_frame
;
3587 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3590 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3592 doc
: /* Force all windows to be updated on next redisplay.
3593 If optional arg OBJECT is a window, force redisplay of that window only.
3594 If OBJECT is a buffer or buffer name, force redisplay of all windows
3595 displaying that buffer. */)
3601 windows_or_buffers_changed
++;
3602 update_mode_lines
++;
3606 if (WINDOWP (object
))
3608 struct window
*w
= XWINDOW (object
);
3609 mark_window_display_accurate (object
, 0);
3610 w
->update_mode_line
= Qt
;
3611 if (BUFFERP (w
->buffer
))
3612 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3613 ++update_mode_lines
;
3617 if (STRINGP (object
))
3618 object
= Fget_buffer (object
);
3619 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3621 /* Walk all windows looking for buffer, and force update
3622 of each of those windows. */
3624 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3625 return NILP (object
) ? Qnil
: Qt
;
3628 /* If nothing suitable was found, just return.
3629 We could signal an error, but this feature will typically be used
3630 asynchronously in timers or process sentinels, so we don't. */
3636 temp_output_buffer_show (buf
)
3637 register Lisp_Object buf
;
3639 register struct buffer
*old
= current_buffer
;
3640 register Lisp_Object window
;
3641 register struct window
*w
;
3643 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3646 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3650 #if 0 /* rms: there should be no reason for this. */
3651 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3653 set_buffer_internal (old
);
3655 if (!NILP (Vtemp_buffer_show_function
))
3656 call1 (Vtemp_buffer_show_function
, buf
);
3659 window
= display_buffer (buf
, Qnil
, Qnil
);
3661 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3662 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3663 Vminibuf_scroll_window
= window
;
3664 w
= XWINDOW (window
);
3665 XSETFASTINT (w
->hscroll
, 0);
3666 XSETFASTINT (w
->min_hscroll
, 0);
3667 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3668 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3670 /* Run temp-buffer-show-hook, with the chosen window selected
3671 and its buffer current. */
3673 if (!NILP (Vrun_hooks
)
3674 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3675 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3677 int count
= SPECPDL_INDEX ();
3678 Lisp_Object prev_window
, prev_buffer
;
3679 prev_window
= selected_window
;
3680 XSETBUFFER (prev_buffer
, old
);
3682 /* Select the window that was chosen, for running the hook.
3683 Note: Both Fselect_window and select_window_norecord may
3684 set-buffer to the buffer displayed in the window,
3685 so we need to save the current buffer. --stef */
3686 record_unwind_protect (Fset_buffer
, prev_buffer
);
3687 record_unwind_protect (select_window_norecord
, prev_window
);
3688 Fselect_window (window
, Qt
);
3689 Fset_buffer (w
->buffer
);
3690 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3691 unbind_to (count
, Qnil
);
3697 make_dummy_parent (window
)
3701 register struct window
*o
, *p
;
3704 o
= XWINDOW (window
);
3705 p
= allocate_window ();
3706 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3707 ((struct Lisp_Vector
*) p
)->contents
[i
]
3708 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3709 XSETWINDOW (new, p
);
3712 XSETFASTINT (p
->sequence_number
, sequence_number
);
3714 /* Put new into window structure in place of window */
3715 replace_window (window
, new);
3728 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3729 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3730 WINDOW defaults to selected one and SIZE to half its size.
3731 If optional third arg HORFLAG is non-nil, split side by side
3732 and put SIZE columns in the first of the pair. In that case,
3733 SIZE includes that window's scroll bar, or the divider column to its right.
3734 Interactively, all arguments are nil.
3736 Returns the newly created window (which is the lower or rightmost one).
3737 The upper or leftmost window is the original one, and remains selected
3738 if it was selected before.
3740 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3741 (window
, size
, horflag
)
3742 Lisp_Object window
, size
, horflag
;
3744 register Lisp_Object
new;
3745 register struct window
*o
, *p
;
3747 register int size_int
;
3750 window
= selected_window
;
3752 CHECK_LIVE_WINDOW (window
);
3754 o
= XWINDOW (window
);
3755 fo
= XFRAME (WINDOW_FRAME (o
));
3759 if (!NILP (horflag
))
3760 /* Calculate the size of the left-hand window, by dividing
3761 the usable space in columns by two.
3762 We round up, since the left-hand window may include
3763 a dividing line, while the right-hand may not. */
3764 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3766 size_int
= XFASTINT (o
->total_lines
) >> 1;
3770 CHECK_NUMBER (size
);
3771 size_int
= XINT (size
);
3774 if (MINI_WINDOW_P (o
))
3775 error ("Attempt to split minibuffer window");
3776 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3777 error ("Attempt to split fixed-size window");
3781 int window_safe_height
= window_min_size_2 (o
, 0, 0);
3783 if (size_int
< window_safe_height
)
3784 error ("Window height %d too small (after splitting)", size_int
);
3785 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
3786 error ("Window height %d too small (after splitting)",
3787 XFASTINT (o
->total_lines
) - size_int
);
3788 if (NILP (o
->parent
)
3789 || NILP (XWINDOW (o
->parent
)->vchild
))
3791 make_dummy_parent (window
);
3793 XWINDOW (new)->vchild
= window
;
3798 int window_safe_width
= window_min_size_2 (o
, 1, 0);
3800 if (size_int
< window_safe_width
)
3801 error ("Window width %d too small (after splitting)", size_int
);
3802 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
3803 error ("Window width %d too small (after splitting)",
3804 XFASTINT (o
->total_cols
) - size_int
);
3805 if (NILP (o
->parent
)
3806 || NILP (XWINDOW (o
->parent
)->hchild
))
3808 make_dummy_parent (window
);
3810 XWINDOW (new)->hchild
= window
;
3814 /* Now we know that window's parent is a vertical combination
3815 if we are dividing vertically, or a horizontal combination
3816 if we are making side-by-side windows */
3818 windows_or_buffers_changed
++;
3819 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3820 new = make_window ();
3823 p
->frame
= o
->frame
;
3825 if (!NILP (p
->next
))
3826 XWINDOW (p
->next
)->prev
= new;
3829 p
->parent
= o
->parent
;
3831 p
->window_end_valid
= Qnil
;
3832 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3834 /* Duplicate special geometry settings. */
3836 p
->left_margin_cols
= o
->left_margin_cols
;
3837 p
->right_margin_cols
= o
->right_margin_cols
;
3838 p
->left_fringe_width
= o
->left_fringe_width
;
3839 p
->right_fringe_width
= o
->right_fringe_width
;
3840 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3841 p
->scroll_bar_width
= o
->scroll_bar_width
;
3842 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3844 /* Apportion the available frame space among the two new windows */
3846 if (!NILP (horflag
))
3848 p
->total_lines
= o
->total_lines
;
3849 p
->top_line
= o
->top_line
;
3850 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3851 XSETFASTINT (o
->total_cols
, size_int
);
3852 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3853 adjust_window_margins (p
);
3854 adjust_window_margins (o
);
3858 p
->left_col
= o
->left_col
;
3859 p
->total_cols
= o
->total_cols
;
3860 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3861 XSETFASTINT (o
->total_lines
, size_int
);
3862 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3865 /* Adjust glyph matrices. */
3868 Fset_window_buffer (new, o
->buffer
, Qt
);
3872 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3873 doc
: /* Make current window ARG lines bigger.
3874 From program, optional second arg non-nil means grow sideways ARG columns.
3875 Interactively, if an argument is not given, make the window one line bigger.
3876 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
3877 This function can delete windows, even the second window, if they get
3880 Lisp_Object arg
, horizontal
;
3883 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
3885 run_window_configuration_change_hook (SELECTED_FRAME ());
3890 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3891 doc
: /* Make current window ARG lines smaller.
3892 From program, optional second arg non-nil means shrink sideways arg columns.
3893 Interactively, if an argument is not given, make the window one line smaller.
3894 Only siblings to the right or below are changed. */)
3896 Lisp_Object arg
, side
;
3899 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3901 run_window_configuration_change_hook (SELECTED_FRAME ());
3907 window_height (window
)
3910 register struct window
*p
= XWINDOW (window
);
3911 return WINDOW_TOTAL_LINES (p
);
3915 window_width (window
)
3918 register struct window
*p
= XWINDOW (window
);
3919 return WINDOW_TOTAL_COLS (p
);
3924 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3926 #define CURSIZE(w) \
3927 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3930 /* Enlarge WINDOW by DELTA. HORIZ_FLAG nonzero means enlarge it
3931 horizontally; zero means do it vertically.
3933 Siblings of the selected window are resized to fulfill the size
3934 request. If they become too small in the process, they may be
3938 enlarge_window (window
, delta
, horiz_flag
)
3940 int delta
, horiz_flag
;
3942 Lisp_Object parent
, next
, prev
;
3946 int (*sizefun
) P_ ((Lisp_Object
))
3947 = horiz_flag
? window_width
: window_height
;
3948 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3949 = (horiz_flag
? set_window_width
: set_window_height
);
3951 /* Give up if this window cannot be resized. */
3952 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3953 error ("Window is not resizable");
3955 /* Find the parent of the selected window. */
3958 p
= XWINDOW (window
);
3964 error ("No other window to side of this one");
3969 ? !NILP (XWINDOW (parent
)->hchild
)
3970 : !NILP (XWINDOW (parent
)->vchild
))
3976 sizep
= &CURSIZE (window
);
3979 register int maxdelta
;
3981 /* Compute the maximum size increment this window can have. */
3983 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3984 /* This is a main window followed by a minibuffer. */
3985 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3986 - window_min_size (XWINDOW (p
->next
),
3987 horiz_flag
, 0, 0, 0))
3988 /* This is a minibuffer following a main window. */
3989 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3990 - window_min_size (XWINDOW (p
->prev
),
3991 horiz_flag
, 0, 0, 0))
3992 /* This is a frame with only one window, a minibuffer-only
3993 or a minibufferless frame. */
3996 if (delta
> maxdelta
)
3997 /* This case traps trying to make the minibuffer
3998 the full frame, or make the only window aside from the
3999 minibuffer the full frame. */
4003 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
),
4004 horiz_flag
, 0, 0, 0))
4006 delete_window (window
);
4013 /* Find the total we can get from other siblings without deleting them. */
4015 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4016 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4017 horiz_flag
, 0, 0, 0);
4018 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4019 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4020 horiz_flag
, 0, 0, 0);
4022 /* If we can get it all from them without deleting them, do so. */
4023 if (delta
<= maximum
)
4025 Lisp_Object first_unaffected
;
4026 Lisp_Object first_affected
;
4031 first_affected
= window
;
4032 /* Look at one sibling at a time,
4033 moving away from this window in both directions alternately,
4034 and take as much as we can get without deleting that sibling. */
4036 && (!NILP (next
) || !NILP (prev
)))
4040 int this_one
= ((*sizefun
) (next
)
4041 - window_min_size (XWINDOW (next
), horiz_flag
,
4045 if (this_one
> delta
)
4048 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4049 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4054 next
= XWINDOW (next
)->next
;
4062 int this_one
= ((*sizefun
) (prev
)
4063 - window_min_size (XWINDOW (prev
), horiz_flag
,
4067 if (this_one
> delta
)
4070 first_affected
= prev
;
4072 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4073 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4078 prev
= XWINDOW (prev
)->prev
;
4082 xassert (delta
== 0);
4084 /* Now recalculate the edge positions of all the windows affected,
4085 based on the new sizes. */
4086 first_unaffected
= next
;
4087 prev
= first_affected
;
4088 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4089 prev
= next
, next
= XWINDOW (next
)->next
)
4091 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4092 /* This does not change size of NEXT,
4093 but it propagates the new top edge to its children */
4094 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4099 register int delta1
;
4100 register int opht
= (*sizefun
) (parent
);
4102 if (opht
<= XINT (*sizep
) + delta
)
4104 /* If trying to grow this window to or beyond size of the parent,
4105 just delete all the sibling windows. */
4106 Lisp_Object start
, tem
, next
;
4108 start
= XWINDOW (parent
)->vchild
;
4110 start
= XWINDOW (parent
)->hchild
;
4112 /* Delete any siblings that come after WINDOW. */
4113 tem
= XWINDOW (window
)->next
;
4114 while (! NILP (tem
))
4116 next
= XWINDOW (tem
)->next
;
4117 delete_window (tem
);
4121 /* Delete any siblings that come after WINDOW.
4122 Note that if START is not WINDOW, then WINDOW still
4123 has siblings, so WINDOW has not yet replaced its parent. */
4125 while (! EQ (tem
, window
))
4127 next
= XWINDOW (tem
)->next
;
4128 delete_window (tem
);
4134 /* Otherwise, make delta1 just right so that if we add
4135 delta1 lines to this window and to the parent, and then
4136 shrink the parent back to its original size, the new
4137 proportional size of this window will increase by delta.
4139 The function size_window will compute the new height h'
4140 of the window from delta1 as:
4143 x = delta1 - delta1/n * n for the 1st resizable child
4146 where n is the number of children that can be resized.
4147 We can ignore x by choosing a delta1 that is a multiple of
4148 n. We want the height of this window to come out as
4158 The number of children n equals the number of resizable
4159 children of this window + 1 because we know window itself
4160 is resizable (otherwise we would have signaled an error).
4162 This reasoning is not correct when other windows become too
4163 small and shrink_windows refuses to delete them. Below we
4164 use resize_proportionally to work around this problem. */
4166 struct window
*w
= XWINDOW (window
);
4170 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4171 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4173 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4174 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4179 /* Add delta1 lines or columns to this window, and to the parent,
4180 keeping things consistent while not affecting siblings. */
4181 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4182 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4184 /* Squeeze out delta1 lines or columns from our parent,
4185 shrinking this window and siblings proportionately. This
4186 brings parent back to correct size. Delta1 was calculated
4187 so this makes this window the desired size, taking it all
4188 out of the siblings.
4190 Temporarily set resize_proportionally to Qt to assure that,
4191 if necessary, shrink_windows deletes smaller windows rather
4192 than shrink this window. */
4193 w
->resize_proportionally
= Qt
;
4194 (*setsizefun
) (parent
, opht
, 0);
4195 w
->resize_proportionally
= Qnil
;
4199 XSETFASTINT (p
->last_modified
, 0);
4200 XSETFASTINT (p
->last_overlay_modified
, 0);
4202 /* Adjust glyph matrices. */
4203 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4207 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4208 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4209 zero means adjust the height, moving the bottom edge.
4211 Following siblings of the selected window are resized to fulfill
4212 the size request. If they become too small in the process, they
4213 are not deleted; instead, we signal an error. */
4216 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4218 int delta
, horiz_flag
;
4220 Lisp_Object parent
, child
;
4222 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4223 int delcount
= window_deletion_count
;
4225 CHECK_WINDOW (window
);
4227 /* Give up if this window cannot be resized. */
4228 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4229 error ("Window is not resizable");
4233 Lisp_Object first_parallel
= Qnil
;
4237 /* This happens if WINDOW on the previous iteration was
4238 at top level of the window tree. */
4239 Fset_window_configuration (old_config
);
4240 error ("Specified window edge is fixed");
4243 p
= XWINDOW (window
);
4246 /* See if this level has windows in parallel in the specified
4247 direction. If so, set FIRST_PARALLEL to the first one. */
4250 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4251 first_parallel
= XWINDOW (parent
)->vchild
;
4252 else if (NILP (parent
) && !NILP (p
->next
))
4254 /* Handle the vertical chain of main window and minibuffer
4255 which has no parent. */
4256 first_parallel
= window
;
4257 while (! NILP (XWINDOW (first_parallel
)->prev
))
4258 first_parallel
= XWINDOW (first_parallel
)->prev
;
4263 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4264 first_parallel
= XWINDOW (parent
)->hchild
;
4267 /* If this level's succession is in the desired dimension,
4268 and this window is the last one, and there is no higher level,
4269 its trailing edge is fixed. */
4270 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4273 Fset_window_configuration (old_config
);
4274 error ("Specified window edge is fixed");
4277 /* Don't make this window too small. */
4278 if (XINT (CURSIZE (window
)) + delta
4279 < window_min_size_2 (XWINDOW (window
), horiz_flag
, 0))
4281 Fset_window_configuration (old_config
);
4282 error ("Cannot adjust window size as specified");
4285 /* Clear out some redisplay caches. */
4286 XSETFASTINT (p
->last_modified
, 0);
4287 XSETFASTINT (p
->last_overlay_modified
, 0);
4289 /* Adjust this window's edge. */
4290 XSETINT (CURSIZE (window
),
4291 XINT (CURSIZE (window
)) + delta
);
4293 /* If this window has following siblings in the desired dimension,
4294 make them smaller, and exit the loop.
4296 (If we reach the top of the tree and can never do this,
4297 we will fail and report an error, above.) */
4298 if (NILP (first_parallel
))
4300 if (!NILP (p
->next
))
4302 /* This may happen for the minibuffer. In that case
4303 the window_deletion_count check below does not work. */
4304 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4306 Fset_window_configuration (old_config
);
4307 error ("Cannot adjust window size as specified");
4310 XSETINT (CURBEG (p
->next
),
4311 XINT (CURBEG (p
->next
)) + delta
);
4312 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4313 horiz_flag
, 0, 1, 0);
4318 /* Here we have a chain of parallel siblings, in the other dimension.
4319 Change the size of the other siblings. */
4320 for (child
= first_parallel
;
4322 child
= XWINDOW (child
)->next
)
4323 if (! EQ (child
, window
))
4324 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4325 horiz_flag
, 0, 0, 1);
4330 /* If we made a window so small it got deleted,
4331 we failed. Report failure. */
4332 if (delcount
!= window_deletion_count
)
4334 Fset_window_configuration (old_config
);
4335 error ("Cannot adjust window size as specified");
4338 /* Adjust glyph matrices. */
4339 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4345 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4346 Sadjust_window_trailing_edge
, 3, 3, 0,
4347 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4348 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4349 Otherwise, adjust the height, moving the bottom edge.
4351 Following siblings of the selected window are resized to fulfill
4352 the size request. If they become too small in the process, they
4353 are not deleted; instead, we signal an error. */)
4354 (window
, delta
, horizontal
)
4355 Lisp_Object window
, delta
, horizontal
;
4357 CHECK_NUMBER (delta
);
4359 window
= selected_window
;
4360 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4362 run_window_configuration_change_hook
4363 (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4370 /***********************************************************************
4371 Resizing Mini-Windows
4372 ***********************************************************************/
4374 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4376 enum save_restore_action
4383 static int save_restore_orig_size
P_ ((struct window
*,
4384 enum save_restore_action
));
4386 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4387 from lowest windows first. */
4390 shrink_window_lowest_first (w
, height
)
4398 xassert (!MINI_WINDOW_P (w
));
4400 /* Set redisplay hints. */
4401 XSETFASTINT (w
->last_modified
, 0);
4402 XSETFASTINT (w
->last_overlay_modified
, 0);
4403 windows_or_buffers_changed
++;
4404 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4406 old_height
= XFASTINT (w
->total_lines
);
4407 XSETFASTINT (w
->total_lines
, height
);
4409 if (!NILP (w
->hchild
))
4411 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4413 c
= XWINDOW (child
);
4414 c
->top_line
= w
->top_line
;
4415 shrink_window_lowest_first (c
, height
);
4418 else if (!NILP (w
->vchild
))
4420 Lisp_Object last_child
;
4421 int delta
= old_height
- height
;
4426 /* Find the last child. We are taking space from lowest windows
4427 first, so we iterate over children from the last child
4429 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4432 /* Size children down to their safe heights. */
4433 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4437 c
= XWINDOW (child
);
4438 this_one
= XFASTINT (c
->total_lines
) - window_min_size_1 (c
, 0, 1);
4440 if (this_one
> delta
)
4443 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4447 /* Compute new positions. */
4448 last_top
= XINT (w
->top_line
);
4449 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4451 c
= XWINDOW (child
);
4452 c
->top_line
= make_number (last_top
);
4453 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4454 last_top
+= XFASTINT (c
->total_lines
);
4460 /* Save, restore, or check positions and sizes in the window tree
4461 rooted at W. ACTION says what to do.
4463 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4464 orig_total_lines members are valid for all windows in the window
4465 tree. Value is non-zero if they are valid.
4467 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4468 orig_top_line and orig_total_lines for all windows in the tree.
4470 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4471 stored in orig_top_line and orig_total_lines for all windows. */
4474 save_restore_orig_size (w
, action
)
4476 enum save_restore_action action
;
4482 if (!NILP (w
->hchild
))
4484 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4487 else if (!NILP (w
->vchild
))
4489 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4495 case CHECK_ORIG_SIZES
:
4496 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4500 case SAVE_ORIG_SIZES
:
4501 w
->orig_top_line
= w
->top_line
;
4502 w
->orig_total_lines
= w
->total_lines
;
4503 XSETFASTINT (w
->last_modified
, 0);
4504 XSETFASTINT (w
->last_overlay_modified
, 0);
4507 case RESTORE_ORIG_SIZES
:
4508 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4509 w
->top_line
= w
->orig_top_line
;
4510 w
->total_lines
= w
->orig_total_lines
;
4511 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4512 XSETFASTINT (w
->last_modified
, 0);
4513 XSETFASTINT (w
->last_overlay_modified
, 0);
4520 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4527 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4528 without deleting other windows. */
4531 grow_mini_window (w
, delta
)
4535 struct frame
*f
= XFRAME (w
->frame
);
4536 struct window
*root
;
4538 xassert (MINI_WINDOW_P (w
));
4539 xassert (delta
>= 0);
4541 /* Compute how much we can enlarge the mini-window without deleting
4543 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4546 int min_height
= window_min_size (root
, 0, 0, 0, 0);
4547 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4548 /* Note that the root window may already be smaller than
4550 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4555 /* Save original window sizes and positions, if not already done. */
4556 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4557 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4559 /* Shrink other windows. */
4560 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4562 /* Grow the mini-window. */
4563 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4564 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4565 XSETFASTINT (w
->last_modified
, 0);
4566 XSETFASTINT (w
->last_overlay_modified
, 0);
4573 /* Shrink mini-window W. If there is recorded info about window sizes
4574 before a call to grow_mini_window, restore recorded window sizes.
4575 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4579 shrink_mini_window (w
)
4582 struct frame
*f
= XFRAME (w
->frame
);
4583 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4585 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4587 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4589 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4590 windows_or_buffers_changed
= 1;
4592 else if (XFASTINT (w
->total_lines
) > 1)
4594 /* Distribute the additional lines of the mini-window
4595 among the other windows. */
4597 XSETWINDOW (window
, w
);
4598 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4604 /* Mark window cursors off for all windows in the window tree rooted
4605 at W by setting their phys_cursor_on_p flag to zero. Called from
4606 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4607 the frame are cleared. */
4610 mark_window_cursors_off (w
)
4615 if (!NILP (w
->hchild
))
4616 mark_window_cursors_off (XWINDOW (w
->hchild
));
4617 else if (!NILP (w
->vchild
))
4618 mark_window_cursors_off (XWINDOW (w
->vchild
));
4620 w
->phys_cursor_on_p
= 0;
4622 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4627 /* Return number of lines of text (not counting mode lines) in W. */
4630 window_internal_height (w
)
4633 int ht
= XFASTINT (w
->total_lines
);
4635 if (!MINI_WINDOW_P (w
))
4637 if (!NILP (w
->parent
)
4638 || !NILP (w
->vchild
)
4639 || !NILP (w
->hchild
)
4642 || WINDOW_WANTS_MODELINE_P (w
))
4645 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4653 /* Return the number of columns in W.
4654 Don't count columns occupied by scroll bars or the vertical bar
4655 separating W from the sibling to its right. */
4658 window_box_text_cols (w
)
4661 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4662 int width
= XINT (w
->total_cols
);
4664 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4665 /* Scroll bars occupy a few columns. */
4666 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4667 else if (!FRAME_WINDOW_P (f
)
4668 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4669 /* The column of `|' characters separating side-by-side windows
4670 occupies one column only. */
4673 if (FRAME_WINDOW_P (f
))
4674 /* On window-systems, fringes and display margins cannot be
4675 used for normal text. */
4676 width
-= (WINDOW_FRINGE_COLS (w
)
4677 + WINDOW_LEFT_MARGIN_COLS (w
)
4678 + WINDOW_RIGHT_MARGIN_COLS (w
));
4684 /************************************************************************
4686 ***********************************************************************/
4688 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4689 N screen-fulls, which is defined as the height of the window minus
4690 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4691 instead. Negative values of N mean scroll down. NOERROR non-zero
4692 means don't signal an error if we try to move over BEGV or ZV,
4696 window_scroll (window
, n
, whole
, noerror
)
4704 /* If we must, use the pixel-based version which is much slower than
4705 the line-based one but can handle varying line heights. */
4706 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4707 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4709 window_scroll_line_based (window
, n
, whole
, noerror
);
4715 /* Implementation of window_scroll that works based on pixel line
4716 heights. See the comment of window_scroll for parameter
4720 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4727 struct window
*w
= XWINDOW (window
);
4728 struct text_pos start
;
4729 int this_scroll_margin
;
4730 /* True if we fiddled the window vscroll field without really scrolling. */
4732 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4734 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4736 /* If PT is not visible in WINDOW, move back one half of
4737 the screen. Allow PT to be partially visible, otherwise
4738 something like (scroll-down 1) with PT in the line before
4739 the partially visible one would recenter. */
4741 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4743 /* Move backward half the height of the window. Performance note:
4744 vmotion used here is about 10% faster, but would give wrong
4745 results for variable height lines. */
4746 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4747 it
.current_y
= it
.last_visible_y
;
4748 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4750 /* The function move_iterator_vertically may move over more than
4751 the specified y-distance. If it->w is small, e.g. a
4752 mini-buffer window, we may end up in front of the window's
4753 display area. This is the case when Start displaying at the
4754 start of the line containing PT in this case. */
4755 if (it
.current_y
<= 0)
4757 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4758 move_it_vertically_backward (&it
, 0);
4762 start
= it
.current
.pos
;
4764 else if (auto_window_vscroll_p
)
4766 if (rtop
|| rbot
) /* partially visible */
4769 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4771 dy
= max ((window_box_height (w
)
4772 - next_screen_context_lines
* dy
),
4778 /* Only vscroll backwards if already vscrolled forwards. */
4779 if (w
->vscroll
< 0 && rtop
> 0)
4781 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4782 Fset_window_vscroll (window
, make_number (px
), Qt
);
4788 /* Do vscroll if already vscrolled or only display line. */
4789 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4791 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4792 Fset_window_vscroll (window
, make_number (px
), Qt
);
4796 /* Maybe modify window start instead of scrolling. */
4797 if (rbot
> 0 || w
->vscroll
< 0)
4801 Fset_window_vscroll (window
, make_number (0), Qt
);
4802 /* If there are other text lines above the current row,
4803 move window start to current row. Else to next row. */
4805 spos
= XINT (Fline_beginning_position (Qnil
));
4807 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4808 set_marker_restricted (w
->start
, make_number (spos
),
4810 w
->start_at_line_beg
= Qt
;
4811 w
->update_mode_line
= Qt
;
4812 XSETFASTINT (w
->last_modified
, 0);
4813 XSETFASTINT (w
->last_overlay_modified
, 0);
4814 /* Set force_start so that redisplay_window will run the
4815 window-scroll-functions. */
4816 w
->force_start
= Qt
;
4821 /* Cancel previous vscroll. */
4822 Fset_window_vscroll (window
, make_number (0), Qt
);
4825 /* If scroll_preserve_screen_position is non-nil, we try to set
4826 point in the same window line as it is now, so get that line. */
4827 if (!NILP (Vscroll_preserve_screen_position
))
4829 /* We preserve the goal pixel coordinate across consecutive
4830 calls to scroll-up or scroll-down. This avoids the
4831 possibility of point becoming "stuck" on a tall line when
4832 scrolling by one line. */
4833 if (window_scroll_pixel_based_preserve_y
< 0
4834 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
4835 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
4837 start_display (&it
, w
, start
);
4838 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4839 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4840 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4844 window_scroll_pixel_based_preserve_y
4845 = window_scroll_pixel_based_preserve_x
= -1;
4847 /* Move iterator it from start the specified distance forward or
4848 backward. The result is the new window start. */
4849 start_display (&it
, w
, start
);
4852 int start_pos
= IT_CHARPOS (it
);
4853 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4854 dy
= max ((window_box_height (w
)
4855 - next_screen_context_lines
* dy
),
4858 /* Note that move_it_vertically always moves the iterator to the
4859 start of a line. So, if the last line doesn't have a newline,
4860 we would end up at the start of the line ending at ZV. */
4863 move_it_vertically_backward (&it
, -dy
);
4864 /* Ensure we actually do move, e.g. in case we are currently
4865 looking at an image that is taller that the window height. */
4866 while (start_pos
== IT_CHARPOS (it
)
4867 && start_pos
> BEGV
)
4868 move_it_by_lines (&it
, -1, 1);
4872 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4873 MOVE_TO_POS
| MOVE_TO_Y
);
4874 /* Ensure we actually do move, e.g. in case we are currently
4875 looking at an image that is taller that the window height. */
4876 while (start_pos
== IT_CHARPOS (it
)
4878 move_it_by_lines (&it
, 1, 1);
4882 move_it_by_lines (&it
, n
, 1);
4884 /* We failed if we find ZV is already on the screen (scrolling up,
4885 means there's nothing past the end), or if we can't start any
4886 earlier (scrolling down, means there's nothing past the top). */
4887 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4888 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4890 if (IT_CHARPOS (it
) == ZV
)
4892 if (it
.current_y
< it
.last_visible_y
4893 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4894 > it
.last_visible_y
))
4896 /* The last line was only partially visible, make it fully
4898 w
->vscroll
= (it
.last_visible_y
4899 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4900 adjust_glyphs (it
.f
);
4904 else if (n
< 0) /* could happen with empty buffers */
4905 xsignal0 (Qbeginning_of_buffer
);
4907 xsignal0 (Qend_of_buffer
);
4911 if (w
->vscroll
!= 0)
4912 /* The first line was only partially visible, make it fully
4918 xsignal0 (Qbeginning_of_buffer
);
4921 /* If control gets here, then we vscrolled. */
4923 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4925 /* Don't try to change the window start below. */
4931 int pos
= IT_CHARPOS (it
);
4934 /* If in the middle of a multi-glyph character move forward to
4935 the next character. */
4936 if (in_display_vector_p (&it
))
4939 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4942 /* Set the window start, and set up the window for redisplay. */
4943 set_marker_restricted (w
->start
, make_number (pos
),
4945 bytepos
= XMARKER (w
->start
)->bytepos
;
4946 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4948 w
->update_mode_line
= Qt
;
4949 XSETFASTINT (w
->last_modified
, 0);
4950 XSETFASTINT (w
->last_overlay_modified
, 0);
4951 /* Set force_start so that redisplay_window will run the
4952 window-scroll-functions. */
4953 w
->force_start
= Qt
;
4956 /* The rest of this function uses current_y in a nonstandard way,
4957 not including the height of the header line if any. */
4958 it
.current_y
= it
.vpos
= 0;
4960 /* Move PT out of scroll margins.
4961 This code wants current_y to be zero at the window start position
4962 even if there is a header line. */
4963 this_scroll_margin
= max (0, scroll_margin
);
4964 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4965 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4969 /* We moved the window start towards ZV, so PT may be now
4970 in the scroll margin at the top. */
4971 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4972 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4973 && (NILP (Vscroll_preserve_screen_position
)
4974 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4975 /* We found PT at a legitimate height. Leave it alone. */
4977 else if (window_scroll_pixel_based_preserve_y
>= 0)
4979 /* If we have a header line, take account of it.
4980 This is necessary because we set it.current_y to 0, above. */
4981 move_it_to (&it
, -1,
4982 window_scroll_pixel_based_preserve_x
,
4983 window_scroll_pixel_based_preserve_y
4984 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4985 -1, MOVE_TO_Y
| MOVE_TO_X
);
4986 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4990 while (it
.current_y
< this_scroll_margin
)
4992 int prev
= it
.current_y
;
4993 move_it_by_lines (&it
, 1, 1);
4994 if (prev
== it
.current_y
)
4997 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5002 int charpos
, bytepos
;
5005 /* Save our position, for the
5006 window_scroll_pixel_based_preserve_y case. */
5007 charpos
= IT_CHARPOS (it
);
5008 bytepos
= IT_BYTEPOS (it
);
5010 /* We moved the window start towards BEGV, so PT may be now
5011 in the scroll margin at the bottom. */
5012 move_it_to (&it
, PT
, -1,
5013 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5014 - this_scroll_margin
- 1),
5016 MOVE_TO_POS
| MOVE_TO_Y
);
5018 /* Save our position, in case it's correct. */
5019 charpos
= IT_CHARPOS (it
);
5020 bytepos
= IT_BYTEPOS (it
);
5022 /* See if point is on a partially visible line at the end. */
5023 if (it
.what
== IT_EOB
)
5024 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5027 move_it_by_lines (&it
, 1, 1);
5028 partial_p
= it
.current_y
> it
.last_visible_y
;
5031 if (charpos
== PT
&& !partial_p
5032 && (NILP (Vscroll_preserve_screen_position
)
5033 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5034 /* We found PT before we found the display margin, so PT is ok. */
5036 else if (window_scroll_pixel_based_preserve_y
>= 0)
5038 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5039 start_display (&it
, w
, start
);
5040 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5041 here because we called start_display again and did not
5042 alter it.current_y this time. */
5043 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
5044 window_scroll_pixel_based_preserve_y
, -1,
5045 MOVE_TO_Y
| MOVE_TO_X
);
5046 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5051 /* The last line was only partially visible, so back up two
5052 lines to make sure we're on a fully visible line. */
5054 move_it_by_lines (&it
, -2, 0);
5055 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5058 /* No, the position we saved is OK, so use it. */
5059 SET_PT_BOTH (charpos
, bytepos
);
5065 /* Implementation of window_scroll that works based on screen lines.
5066 See the comment of window_scroll for parameter descriptions. */
5069 window_scroll_line_based (window
, n
, whole
, noerror
)
5075 register struct window
*w
= XWINDOW (window
);
5076 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5077 register int pos
, pos_byte
;
5078 register int ht
= window_internal_height (w
);
5079 register Lisp_Object tem
;
5083 Lisp_Object original_pos
= Qnil
;
5085 /* If scrolling screen-fulls, compute the number of lines to
5086 scroll from the window's height. */
5088 n
*= max (1, ht
- next_screen_context_lines
);
5090 startpos
= marker_position (w
->start
);
5092 if (!NILP (Vscroll_preserve_screen_position
))
5094 if (window_scroll_preserve_vpos
<= 0
5095 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5096 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5098 struct position posit
5099 = *compute_motion (startpos
, 0, 0, 0,
5101 -1, XINT (w
->hscroll
),
5103 window_scroll_preserve_vpos
= posit
.vpos
;
5104 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
5107 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
5108 make_number (window_scroll_preserve_vpos
));
5111 XSETFASTINT (tem
, PT
);
5112 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5116 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5121 lose
= n
< 0 && PT
== BEGV
;
5122 Fvertical_motion (make_number (n
), window
);
5126 SET_PT_BOTH (opoint
, opoint_byte
);
5133 xsignal0 (Qbeginning_of_buffer
);
5138 int this_scroll_margin
= scroll_margin
;
5140 /* Don't use a scroll margin that is negative or too large. */
5141 if (this_scroll_margin
< 0)
5142 this_scroll_margin
= 0;
5144 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5145 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5147 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5148 w
->start_at_line_beg
= bolp
;
5149 w
->update_mode_line
= Qt
;
5150 XSETFASTINT (w
->last_modified
, 0);
5151 XSETFASTINT (w
->last_overlay_modified
, 0);
5152 /* Set force_start so that redisplay_window will run
5153 the window-scroll-functions. */
5154 w
->force_start
= Qt
;
5156 if (!NILP (Vscroll_preserve_screen_position
)
5157 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5159 SET_PT_BOTH (pos
, pos_byte
);
5160 Fvertical_motion (original_pos
, window
);
5162 /* If we scrolled forward, put point enough lines down
5163 that it is outside the scroll margin. */
5168 if (this_scroll_margin
> 0)
5170 SET_PT_BOTH (pos
, pos_byte
);
5171 Fvertical_motion (make_number (this_scroll_margin
), window
);
5177 if (top_margin
<= opoint
)
5178 SET_PT_BOTH (opoint
, opoint_byte
);
5179 else if (!NILP (Vscroll_preserve_screen_position
))
5181 SET_PT_BOTH (pos
, pos_byte
);
5182 Fvertical_motion (original_pos
, window
);
5185 SET_PT (top_margin
);
5191 /* If we scrolled backward, put point near the end of the window
5192 but not within the scroll margin. */
5193 SET_PT_BOTH (pos
, pos_byte
);
5194 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5195 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5198 bottom_margin
= PT
+ 1;
5200 if (bottom_margin
> opoint
)
5201 SET_PT_BOTH (opoint
, opoint_byte
);
5204 if (!NILP (Vscroll_preserve_screen_position
))
5206 SET_PT_BOTH (pos
, pos_byte
);
5207 Fvertical_motion (original_pos
, window
);
5210 Fvertical_motion (make_number (-1), window
);
5219 xsignal0 (Qend_of_buffer
);
5224 /* Scroll selected_window up or down. If N is nil, scroll a
5225 screen-full which is defined as the height of the window minus
5226 next_screen_context_lines. If N is the symbol `-', scroll.
5227 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5228 up. This is the guts of Fscroll_up and Fscroll_down. */
5231 scroll_command (n
, direction
)
5235 int count
= SPECPDL_INDEX ();
5237 xassert (eabs (direction
) == 1);
5239 /* If selected window's buffer isn't current, make it current for
5240 the moment. But don't screw up if window_scroll gets an error. */
5241 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5243 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5244 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5246 /* Make redisplay consider other windows than just selected_window. */
5247 ++windows_or_buffers_changed
;
5251 window_scroll (selected_window
, direction
, 1, 0);
5252 else if (EQ (n
, Qminus
))
5253 window_scroll (selected_window
, -direction
, 1, 0);
5256 n
= Fprefix_numeric_value (n
);
5257 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5260 unbind_to (count
, Qnil
);
5263 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
5264 doc
: /* Scroll text of current window upward ARG lines.
5265 If ARG is omitted or nil, scroll upward by a near full screen.
5266 A near full screen is `next-screen-context-lines' less than a full screen.
5267 Negative ARG means scroll downward.
5268 If ARG is the atom `-', scroll downward by nearly full screen.
5269 When calling from a program, supply as argument a number, nil, or `-'. */)
5273 scroll_command (arg
, 1);
5277 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
5278 doc
: /* Scroll text of current window down ARG lines.
5279 If ARG is omitted or nil, scroll down by a near full screen.
5280 A near full screen is `next-screen-context-lines' less than a full screen.
5281 Negative ARG means scroll upward.
5282 If ARG is the atom `-', scroll upward by nearly full screen.
5283 When calling from a program, supply as argument a number, nil, or `-'. */)
5287 scroll_command (arg
, -1);
5291 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5292 doc
: /* Return the other window for \"other window scroll\" commands.
5293 If `other-window-scroll-buffer' is non-nil, a window
5294 showing that buffer is used.
5295 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5296 specifies the window. This takes precedence over
5297 `other-window-scroll-buffer'. */)
5302 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5303 && !NILP (Vminibuf_scroll_window
))
5304 window
= Vminibuf_scroll_window
;
5305 /* If buffer is specified, scroll that buffer. */
5306 else if (!NILP (Vother_window_scroll_buffer
))
5308 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5310 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5314 /* Nothing specified; look for a neighboring window on the same
5316 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5318 if (EQ (window
, selected_window
))
5319 /* That didn't get us anywhere; look for a window on another
5322 window
= Fnext_window (window
, Qnil
, Qt
);
5323 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5324 && ! EQ (window
, selected_window
));
5327 CHECK_LIVE_WINDOW (window
);
5329 if (EQ (window
, selected_window
))
5330 error ("There is no other window");
5335 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5336 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5337 A near full screen is `next-screen-context-lines' less than a full screen.
5338 The next window is the one below the current one; or the one at the top
5339 if the current one is at the bottom. Negative ARG means scroll downward.
5340 If ARG is the atom `-', scroll downward by nearly full screen.
5341 When calling from a program, supply as argument a number, nil, or `-'.
5343 If `other-window-scroll-buffer' is non-nil, scroll the window
5344 showing that buffer, popping the buffer up if necessary.
5345 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5346 specifies the window to scroll. This takes precedence over
5347 `other-window-scroll-buffer'. */)
5353 int count
= SPECPDL_INDEX ();
5355 window
= Fother_window_for_scrolling ();
5356 w
= XWINDOW (window
);
5358 /* Don't screw up if window_scroll gets an error. */
5359 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5360 ++windows_or_buffers_changed
;
5362 Fset_buffer (w
->buffer
);
5363 SET_PT (marker_position (w
->pointm
));
5366 window_scroll (window
, 1, 1, 1);
5367 else if (EQ (arg
, Qminus
))
5368 window_scroll (window
, -1, 1, 1);
5374 window_scroll (window
, XINT (arg
), 0, 1);
5377 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5378 unbind_to (count
, Qnil
);
5383 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5384 doc
: /* Scroll selected window display ARG columns left.
5385 Default for ARG is window width minus 2.
5386 Value is the total amount of leftward horizontal scrolling in
5387 effect after the change.
5388 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5389 lower bound for automatic scrolling, i.e. automatic scrolling
5390 will not scroll a window to a column less than the value returned
5391 by this function. This happens in an interactive call. */)
5393 register Lisp_Object arg
, set_minimum
;
5397 struct window
*w
= XWINDOW (selected_window
);
5400 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5402 arg
= Fprefix_numeric_value (arg
);
5404 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5405 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5407 if (!NILP (set_minimum
))
5408 w
->min_hscroll
= w
->hscroll
;
5413 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5414 doc
: /* Scroll selected window display ARG columns right.
5415 Default for ARG is window width minus 2.
5416 Value is the total amount of leftward horizontal scrolling in
5417 effect after the change.
5418 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5419 lower bound for automatic scrolling, i.e. automatic scrolling
5420 will not scroll a window to a column less than the value returned
5421 by this function. This happens in an interactive call. */)
5423 register Lisp_Object arg
, set_minimum
;
5427 struct window
*w
= XWINDOW (selected_window
);
5430 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5432 arg
= Fprefix_numeric_value (arg
);
5434 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5435 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5437 if (!NILP (set_minimum
))
5438 w
->min_hscroll
= w
->hscroll
;
5443 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5444 doc
: /* Return the window which was selected when entering the minibuffer.
5445 Returns nil, if current window is not a minibuffer window. */)
5448 if (minibuf_level
> 0
5449 && MINI_WINDOW_P (XWINDOW (selected_window
))
5450 && WINDOW_LIVE_P (minibuf_selected_window
))
5451 return minibuf_selected_window
;
5456 /* Value is the number of lines actually displayed in window W,
5457 as opposed to its height. */
5460 displayed_window_lines (w
)
5464 struct text_pos start
;
5465 int height
= window_box_height (w
);
5466 struct buffer
*old_buffer
;
5469 if (XBUFFER (w
->buffer
) != current_buffer
)
5471 old_buffer
= current_buffer
;
5472 set_buffer_internal (XBUFFER (w
->buffer
));
5477 /* In case W->start is out of the accessible range, do something
5478 reasonable. This happens in Info mode when Info-scroll-down
5479 calls (recenter -1) while W->start is 1. */
5480 if (XMARKER (w
->start
)->charpos
< BEGV
)
5481 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5482 else if (XMARKER (w
->start
)->charpos
> ZV
)
5483 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5485 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5487 start_display (&it
, w
, start
);
5488 move_it_vertically (&it
, height
);
5489 bottom_y
= line_bottom_y (&it
);
5491 /* rms: On a non-window display,
5492 the value of it.vpos at the bottom of the screen
5493 seems to be 1 larger than window_box_height (w).
5494 This kludge fixes a bug whereby (move-to-window-line -1)
5495 when ZV is on the last screen line
5496 moves to the previous screen line instead of the last one. */
5497 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5500 /* Add in empty lines at the bottom of the window. */
5501 if (bottom_y
< height
)
5503 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5504 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5508 set_buffer_internal (old_buffer
);
5514 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5515 doc
: /* Center point in window and redisplay frame.
5516 With prefix argument ARG, recenter putting point on screen line ARG
5517 relative to the current window. If ARG is negative, it counts up from the
5518 bottom of the window. (ARG should be less than the height of the window.)
5520 If ARG is omitted or nil, erase the entire frame and then redraw with point
5521 in the center of the current window. If `auto-resize-tool-bars' is set to
5522 `grow-only', this resets the tool-bar's height to the minimum height needed.
5524 Just C-u as prefix means put point in the center of the window
5525 and redisplay normally--don't erase and redraw the frame. */)
5527 register Lisp_Object arg
;
5529 struct window
*w
= XWINDOW (selected_window
);
5530 struct buffer
*buf
= XBUFFER (w
->buffer
);
5531 struct buffer
*obuf
= current_buffer
;
5533 int charpos
, bytepos
;
5535 int this_scroll_margin
;
5537 /* If redisplay is suppressed due to an error, try again. */
5538 obuf
->display_error_modiff
= 0;
5544 /* Invalidate pixel data calculated for all compositions. */
5545 for (i
= 0; i
< n_compositions
; i
++)
5546 composition_table
[i
]->font
= NULL
;
5548 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5550 Fredraw_frame (WINDOW_FRAME (w
));
5551 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5554 else if (CONSP (arg
)) /* Just C-u. */
5558 arg
= Fprefix_numeric_value (arg
);
5563 set_buffer_internal (buf
);
5565 /* Do this after making BUF current
5566 in case scroll_margin is buffer-local. */
5567 this_scroll_margin
= max (0, scroll_margin
);
5568 this_scroll_margin
= min (this_scroll_margin
,
5569 XFASTINT (w
->total_lines
) / 4);
5571 /* Handle centering on a graphical frame specially. Such frames can
5572 have variable-height lines and centering point on the basis of
5573 line counts would lead to strange effects. */
5574 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5581 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5582 start_display (&it
, w
, pt
);
5583 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5584 charpos
= IT_CHARPOS (it
);
5585 bytepos
= IT_BYTEPOS (it
);
5592 int extra_line_spacing
;
5593 int h
= window_box_height (w
);
5595 iarg
= - max (-iarg
, this_scroll_margin
);
5597 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5598 start_display (&it
, w
, pt
);
5600 /* Be sure we have the exact height of the full line containing PT. */
5601 move_it_by_lines (&it
, 0, 1);
5603 /* The amount of pixels we have to move back is the window
5604 height minus what's displayed in the line containing PT,
5605 and the lines below. */
5608 move_it_by_lines (&it
, nlines
, 1);
5610 if (it
.vpos
== nlines
)
5614 /* Last line has no newline */
5615 h
-= line_bottom_y (&it
);
5619 /* Don't reserve space for extra line spacing of last line. */
5620 extra_line_spacing
= it
.max_extra_line_spacing
;
5622 /* If we can't move down NLINES lines because we hit
5623 the end of the buffer, count in some empty lines. */
5624 if (it
.vpos
< nlines
)
5627 extra_line_spacing
= it
.extra_line_spacing
;
5628 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5633 /* Now find the new top line (starting position) of the window. */
5634 start_display (&it
, w
, pt
);
5636 move_it_vertically_backward (&it
, h
);
5638 /* If extra line spacing is present, we may move too far
5639 back. This causes the last line to be only partially
5640 visible (which triggers redisplay to recenter that line
5641 in the middle), so move forward.
5642 But ignore extra line spacing on last line, as it is not
5643 considered to be part of the visible height of the line.
5645 h
+= extra_line_spacing
;
5646 while (-it
.current_y
> h
)
5647 move_it_by_lines (&it
, 1, 1);
5649 charpos
= IT_CHARPOS (it
);
5650 bytepos
= IT_BYTEPOS (it
);
5654 struct position pos
;
5656 iarg
= max (iarg
, this_scroll_margin
);
5658 pos
= *vmotion (PT
, -iarg
, w
);
5659 charpos
= pos
.bufpos
;
5660 bytepos
= pos
.bytepos
;
5665 struct position pos
;
5666 int ht
= window_internal_height (w
);
5673 /* Don't let it get into the margin at either top or bottom. */
5674 iarg
= max (iarg
, this_scroll_margin
);
5675 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5677 pos
= *vmotion (PT
, - iarg
, w
);
5678 charpos
= pos
.bufpos
;
5679 bytepos
= pos
.bytepos
;
5682 /* Set the new window start. */
5683 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5684 w
->window_end_valid
= Qnil
;
5686 w
->optional_new_start
= Qt
;
5688 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5689 w
->start_at_line_beg
= Qt
;
5691 w
->start_at_line_beg
= Qnil
;
5693 set_buffer_internal (obuf
);
5698 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5700 doc
: /* Return the height in lines of the text display area of WINDOW.
5701 WINDOW defaults to the selected window.
5702 This doesn't include the mode-line (or header-line if any) or any
5703 partial-height lines in the text display area. */)
5707 struct window
*w
= decode_window (window
);
5708 int pixel_height
= window_box_height (w
);
5709 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5710 return make_number (line_height
);
5715 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5717 doc
: /* Position point relative to window.
5718 With no argument, position point at center of window.
5719 An argument specifies vertical position within the window;
5720 zero means top of window, negative means relative to bottom of window. */)
5724 struct window
*w
= XWINDOW (selected_window
);
5728 int this_scroll_margin
;
5731 window
= selected_window
;
5732 start
= marker_position (w
->start
);
5733 if (start
< BEGV
|| start
> ZV
)
5735 int height
= window_internal_height (w
);
5736 Fvertical_motion (make_number (- (height
/ 2)), window
);
5737 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5738 w
->start_at_line_beg
= Fbolp ();
5739 w
->force_start
= Qt
;
5742 Fgoto_char (w
->start
);
5744 lines
= displayed_window_lines (w
);
5747 this_scroll_margin
= max (0, scroll_margin
);
5748 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5752 XSETFASTINT (arg
, lines
/ 2);
5755 int iarg
= XINT (Fprefix_numeric_value (arg
));
5758 iarg
= iarg
+ lines
;
5760 #if 0 /* This code would prevent move-to-window-line from moving point
5761 to a place inside the scroll margins (which would cause the
5762 next redisplay to scroll). I wrote this code, but then concluded
5763 it is probably better not to install it. However, it is here
5764 inside #if 0 so as not to lose it. -- rms. */
5766 /* Don't let it get into the margin at either top or bottom. */
5767 iarg
= max (iarg
, this_scroll_margin
);
5768 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5771 arg
= make_number (iarg
);
5774 /* Skip past a partially visible first line. */
5776 XSETINT (arg
, XINT (arg
) + 1);
5778 return Fvertical_motion (arg
, window
);
5783 /***********************************************************************
5784 Window Configuration
5785 ***********************************************************************/
5787 struct save_window_data
5790 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5791 Lisp_Object selected_frame
;
5792 Lisp_Object current_window
;
5793 Lisp_Object current_buffer
;
5794 Lisp_Object minibuf_scroll_window
;
5795 Lisp_Object minibuf_selected_window
;
5796 Lisp_Object root_window
;
5797 Lisp_Object focus_frame
;
5798 /* A vector, each of whose elements is a struct saved_window
5800 Lisp_Object saved_windows
;
5802 /* All fields above are traced by the GC.
5803 From `fame-cols' down, the fields are ignored by the GC. */
5805 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5806 int frame_tool_bar_lines
;
5809 /* This is saved as a Lisp_Vector */
5812 /* these first two must agree with struct Lisp_Vector in lisp.h */
5814 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5817 Lisp_Object buffer
, start
, pointm
, mark
;
5818 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5819 Lisp_Object hscroll
, min_hscroll
;
5820 Lisp_Object parent
, prev
;
5821 Lisp_Object start_at_line_beg
;
5822 Lisp_Object display_table
;
5823 Lisp_Object orig_top_line
, orig_total_lines
;
5824 Lisp_Object left_margin_cols
, right_margin_cols
;
5825 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5826 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5827 Lisp_Object dedicated
, resize_proportionally
;
5830 #define SAVED_WINDOW_N(swv,n) \
5831 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5833 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5834 doc
: /* Return t if OBJECT is a window-configuration object. */)
5838 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5841 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5842 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5846 register struct save_window_data
*data
;
5847 struct Lisp_Vector
*saved_windows
;
5849 CHECK_WINDOW_CONFIGURATION (config
);
5851 data
= (struct save_window_data
*) XVECTOR (config
);
5852 saved_windows
= XVECTOR (data
->saved_windows
);
5853 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5856 DEFUN ("set-window-configuration", Fset_window_configuration
,
5857 Sset_window_configuration
, 1, 1, 0,
5858 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5859 CONFIGURATION must be a value previously returned
5860 by `current-window-configuration' (which see).
5861 If CONFIGURATION was made from a frame that is now deleted,
5862 only frame-independent values can be restored. In this case,
5863 the return value is nil. Otherwise the value is t. */)
5865 Lisp_Object configuration
;
5867 register struct save_window_data
*data
;
5868 struct Lisp_Vector
*saved_windows
;
5869 Lisp_Object new_current_buffer
;
5874 CHECK_WINDOW_CONFIGURATION (configuration
);
5876 data
= (struct save_window_data
*) XVECTOR (configuration
);
5877 saved_windows
= XVECTOR (data
->saved_windows
);
5879 new_current_buffer
= data
->current_buffer
;
5880 if (NILP (XBUFFER (new_current_buffer
)->name
))
5881 new_current_buffer
= Qnil
;
5884 if (XBUFFER (new_current_buffer
) == current_buffer
)
5885 /* The code further down "preserves point" by saving here PT in
5886 old_point and then setting it later back into PT. When the
5887 current-selected-window and the final-selected-window both show
5888 the current buffer, this suffers from the problem that the
5889 current PT is the window-point of the current-selected-window,
5890 while the final PT is the point of the final-selected-window, so
5891 this copy from one PT to the other would end up moving the
5892 window-point of the final-selected-window to the window-point of
5893 the current-selected-window. So we have to be careful which
5894 point of the current-buffer we copy into old_point. */
5895 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5896 && WINDOWP (selected_window
)
5897 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5898 && !EQ (selected_window
, data
->current_window
))
5899 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5903 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5904 point in new_current_buffer as of the last time this buffer was
5905 used. This can be non-deterministic since it can be changed by
5906 things like jit-lock by mere temporary selection of some random
5907 window that happens to show this buffer.
5908 So if possible we want this arbitrary choice of "which point" to
5909 be the one from the to-be-selected-window so as to prevent this
5910 window's cursor from being copied from another window. */
5911 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5912 /* If current_window = selected_window, its point is in BUF_PT. */
5913 && !EQ (selected_window
, data
->current_window
))
5914 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5916 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5919 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5922 /* If f is a dead frame, don't bother rebuilding its window tree.
5923 However, there is other stuff we should still try to do below. */
5924 if (FRAME_LIVE_P (f
))
5926 register struct window
*w
;
5927 register struct saved_window
*p
;
5928 struct window
*root_window
;
5929 struct window
**leaf_windows
;
5933 /* If the frame has been resized since this window configuration was
5934 made, we change the frame to the size specified in the
5935 configuration, restore the configuration, and then resize it
5936 back. We keep track of the prevailing height in these variables. */
5937 int previous_frame_lines
= FRAME_LINES (f
);
5938 int previous_frame_cols
= FRAME_COLS (f
);
5939 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5940 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5942 /* The mouse highlighting code could get screwed up
5943 if it runs during this. */
5946 if (data
->frame_lines
!= previous_frame_lines
5947 || data
->frame_cols
!= previous_frame_cols
)
5948 change_frame_size (f
, data
->frame_lines
,
5949 data
->frame_cols
, 0, 0, 0);
5950 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5951 if (data
->frame_menu_bar_lines
5952 != previous_frame_menu_bar_lines
)
5953 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5955 #ifdef HAVE_WINDOW_SYSTEM
5956 if (data
->frame_tool_bar_lines
5957 != previous_frame_tool_bar_lines
)
5958 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5963 /* "Swap out" point from the selected window's buffer
5964 into the window itself. (Normally the pointm of the selected
5965 window holds garbage.) We do this now, before
5966 restoring the window contents, and prevent it from
5967 being done later on when we select a new window. */
5968 if (! NILP (XWINDOW (selected_window
)->buffer
))
5970 w
= XWINDOW (selected_window
);
5971 set_marker_both (w
->pointm
,
5973 BUF_PT (XBUFFER (w
->buffer
)),
5974 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5977 windows_or_buffers_changed
++;
5978 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5980 /* Problem: Freeing all matrices and later allocating them again
5981 is a serious redisplay flickering problem. What we would
5982 really like to do is to free only those matrices not reused
5984 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5986 = (struct window
**) alloca (count_windows (root_window
)
5987 * sizeof (struct window
*));
5988 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5991 Mark all windows now on frame as "deleted".
5992 Restoring the new configuration "undeletes" any that are in it.
5994 Save their current buffers in their height fields, since we may
5995 need it later, if a buffer saved in the configuration is now
5997 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5999 for (k
= 0; k
< saved_windows
->size
; k
++)
6001 p
= SAVED_WINDOW_N (saved_windows
, k
);
6002 w
= XWINDOW (p
->window
);
6005 if (!NILP (p
->parent
))
6006 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6007 XFASTINT (p
->parent
))->window
;
6011 if (!NILP (p
->prev
))
6013 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6014 XFASTINT (p
->prev
))->window
;
6015 XWINDOW (w
->prev
)->next
= p
->window
;
6020 if (!NILP (w
->parent
))
6022 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6024 XWINDOW (w
->parent
)->vchild
= p
->window
;
6025 XWINDOW (w
->parent
)->hchild
= Qnil
;
6029 XWINDOW (w
->parent
)->hchild
= p
->window
;
6030 XWINDOW (w
->parent
)->vchild
= Qnil
;
6035 /* If we squirreled away the buffer in the window's height,
6037 if (BUFFERP (w
->total_lines
))
6038 w
->buffer
= w
->total_lines
;
6039 w
->left_col
= p
->left_col
;
6040 w
->top_line
= p
->top_line
;
6041 w
->total_cols
= p
->total_cols
;
6042 w
->total_lines
= p
->total_lines
;
6043 w
->hscroll
= p
->hscroll
;
6044 w
->min_hscroll
= p
->min_hscroll
;
6045 w
->display_table
= p
->display_table
;
6046 w
->orig_top_line
= p
->orig_top_line
;
6047 w
->orig_total_lines
= p
->orig_total_lines
;
6048 w
->left_margin_cols
= p
->left_margin_cols
;
6049 w
->right_margin_cols
= p
->right_margin_cols
;
6050 w
->left_fringe_width
= p
->left_fringe_width
;
6051 w
->right_fringe_width
= p
->right_fringe_width
;
6052 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6053 w
->scroll_bar_width
= p
->scroll_bar_width
;
6054 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6055 w
->dedicated
= p
->dedicated
;
6056 w
->resize_proportionally
= p
->resize_proportionally
;
6057 XSETFASTINT (w
->last_modified
, 0);
6058 XSETFASTINT (w
->last_overlay_modified
, 0);
6060 /* Reinstall the saved buffer and pointers into it. */
6061 if (NILP (p
->buffer
))
6062 w
->buffer
= p
->buffer
;
6065 if (!NILP (XBUFFER (p
->buffer
)->name
))
6066 /* If saved buffer is alive, install it. */
6068 w
->buffer
= p
->buffer
;
6069 w
->start_at_line_beg
= p
->start_at_line_beg
;
6070 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6071 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6072 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6073 p
->mark
, w
->buffer
);
6075 /* As documented in Fcurrent_window_configuration, don't
6076 restore the location of point in the buffer which was
6077 current when the window configuration was recorded. */
6078 if (!EQ (p
->buffer
, new_current_buffer
)
6079 && XBUFFER (p
->buffer
) == current_buffer
)
6080 Fgoto_char (w
->pointm
);
6082 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6083 /* Else unless window has a live buffer, get one. */
6085 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6086 /* This will set the markers to beginning of visible
6088 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6089 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6090 w
->start_at_line_beg
= Qt
;
6093 /* Keeping window's old buffer; make sure the markers
6096 /* Set window markers at start of visible range. */
6097 if (XMARKER (w
->start
)->buffer
== 0)
6098 set_marker_restricted (w
->start
, make_number (0),
6100 if (XMARKER (w
->pointm
)->buffer
== 0)
6101 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6102 BUF_PT (XBUFFER (w
->buffer
)),
6103 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6104 w
->start_at_line_beg
= Qt
;
6109 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6110 /* Prevent "swapping out point" in the old selected window
6111 using the buffer that has been restored into it.
6112 We already swapped out point that from that window's old buffer. */
6113 selected_window
= Qnil
;
6115 /* Arrange *not* to restore point in the buffer that was
6116 current when the window configuration was saved. */
6117 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6118 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6119 make_number (old_point
),
6120 XWINDOW (data
->current_window
)->buffer
);
6122 Fselect_window (data
->current_window
, Qnil
);
6123 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6126 if (NILP (data
->focus_frame
)
6127 || (FRAMEP (data
->focus_frame
)
6128 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6129 Fredirect_frame_focus (frame
, data
->focus_frame
);
6131 #if 0 /* I don't understand why this is needed, and it causes problems
6132 when the frame's old selected window has been deleted. */
6133 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6134 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6138 /* Set the screen height to the value it had before this function. */
6139 if (previous_frame_lines
!= FRAME_LINES (f
)
6140 || previous_frame_cols
!= FRAME_COLS (f
))
6141 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6143 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6144 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6145 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6147 #ifdef HAVE_WINDOW_SYSTEM
6148 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6149 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6154 /* Now, free glyph matrices in windows that were not reused. */
6155 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6157 if (NILP (leaf_windows
[i
]->buffer
))
6159 /* Assert it's not reused as a combination. */
6160 xassert (NILP (leaf_windows
[i
]->hchild
)
6161 && NILP (leaf_windows
[i
]->vchild
));
6162 free_window_matrices (leaf_windows
[i
]);
6164 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6172 /* Fselect_window will have made f the selected frame, so we
6173 reselect the proper frame here. Fhandle_switch_frame will change the
6174 selected window too, but that doesn't make the call to
6175 Fselect_window above totally superfluous; it still sets f's
6177 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6178 do_switch_frame (data
->selected_frame
, 0, 0);
6180 run_window_configuration_change_hook (f
);
6183 if (!NILP (new_current_buffer
))
6184 Fset_buffer (new_current_buffer
);
6186 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6187 minibuf_selected_window
= data
->minibuf_selected_window
;
6189 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6192 /* Mark all windows now on frame as deleted
6193 by setting their buffers to nil. */
6196 delete_all_subwindows (w
)
6197 register struct window
*w
;
6199 if (!NILP (w
->next
))
6200 delete_all_subwindows (XWINDOW (w
->next
));
6201 if (!NILP (w
->vchild
))
6202 delete_all_subwindows (XWINDOW (w
->vchild
));
6203 if (!NILP (w
->hchild
))
6204 delete_all_subwindows (XWINDOW (w
->hchild
));
6206 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6208 if (!NILP (w
->buffer
))
6211 /* We set all three of these fields to nil, to make sure that we can
6212 distinguish this dead window from any live window. Live leaf
6213 windows will have buffer set, and combination windows will have
6214 vchild or hchild set. */
6219 Vwindow_list
= Qnil
;
6223 count_windows (window
)
6224 register struct window
*window
;
6226 register int count
= 1;
6227 if (!NILP (window
->next
))
6228 count
+= count_windows (XWINDOW (window
->next
));
6229 if (!NILP (window
->vchild
))
6230 count
+= count_windows (XWINDOW (window
->vchild
));
6231 if (!NILP (window
->hchild
))
6232 count
+= count_windows (XWINDOW (window
->hchild
));
6237 /* Fill vector FLAT with leaf windows under W, starting at index I.
6238 Value is last index + 1. */
6241 get_leaf_windows (w
, flat
, i
)
6243 struct window
**flat
;
6248 if (!NILP (w
->hchild
))
6249 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6250 else if (!NILP (w
->vchild
))
6251 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6255 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6262 /* Return a pointer to the glyph W's physical cursor is on. Value is
6263 null if W's current matrix is invalid, so that no meaningfull glyph
6267 get_phys_cursor_glyph (w
)
6270 struct glyph_row
*row
;
6271 struct glyph
*glyph
;
6273 if (w
->phys_cursor
.vpos
>= 0
6274 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6275 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6277 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6278 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6287 save_window_save (window
, vector
, i
)
6289 struct Lisp_Vector
*vector
;
6292 register struct saved_window
*p
;
6293 register struct window
*w
;
6294 register Lisp_Object tem
;
6296 for (;!NILP (window
); window
= w
->next
)
6298 p
= SAVED_WINDOW_N (vector
, i
);
6299 w
= XWINDOW (window
);
6301 XSETFASTINT (w
->temslot
, i
); i
++;
6303 p
->buffer
= w
->buffer
;
6304 p
->left_col
= w
->left_col
;
6305 p
->top_line
= w
->top_line
;
6306 p
->total_cols
= w
->total_cols
;
6307 p
->total_lines
= w
->total_lines
;
6308 p
->hscroll
= w
->hscroll
;
6309 p
->min_hscroll
= w
->min_hscroll
;
6310 p
->display_table
= w
->display_table
;
6311 p
->orig_top_line
= w
->orig_top_line
;
6312 p
->orig_total_lines
= w
->orig_total_lines
;
6313 p
->left_margin_cols
= w
->left_margin_cols
;
6314 p
->right_margin_cols
= w
->right_margin_cols
;
6315 p
->left_fringe_width
= w
->left_fringe_width
;
6316 p
->right_fringe_width
= w
->right_fringe_width
;
6317 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6318 p
->scroll_bar_width
= w
->scroll_bar_width
;
6319 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6320 p
->dedicated
= w
->dedicated
;
6321 p
->resize_proportionally
= w
->resize_proportionally
;
6322 if (!NILP (w
->buffer
))
6324 /* Save w's value of point in the window configuration.
6325 If w is the selected window, then get the value of point
6326 from the buffer; pointm is garbage in the selected window. */
6327 if (EQ (window
, selected_window
))
6329 p
->pointm
= Fmake_marker ();
6330 set_marker_both (p
->pointm
, w
->buffer
,
6331 BUF_PT (XBUFFER (w
->buffer
)),
6332 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6335 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6337 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6338 p
->start_at_line_beg
= w
->start_at_line_beg
;
6340 tem
= XBUFFER (w
->buffer
)->mark
;
6341 p
->mark
= Fcopy_marker (tem
, Qnil
);
6348 p
->start_at_line_beg
= Qnil
;
6351 if (NILP (w
->parent
))
6354 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6359 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6361 if (!NILP (w
->vchild
))
6362 i
= save_window_save (w
->vchild
, vector
, i
);
6363 if (!NILP (w
->hchild
))
6364 i
= save_window_save (w
->hchild
, vector
, i
);
6370 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6371 Scurrent_window_configuration
, 0, 1, 0,
6372 doc
: /* Return an object representing the current window configuration of FRAME.
6373 If FRAME is nil or omitted, use the selected frame.
6374 This describes the number of windows, their sizes and current buffers,
6375 and for each displayed buffer, where display starts, and the positions of
6376 point and mark. An exception is made for point in the current buffer:
6377 its value is -not- saved.
6378 This also records the currently selected frame, and FRAME's focus
6379 redirection (see `redirect-frame-focus'). */)
6383 register Lisp_Object tem
;
6384 register int n_windows
;
6385 register struct save_window_data
*data
;
6390 frame
= selected_frame
;
6391 CHECK_LIVE_FRAME (frame
);
6394 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6395 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6396 PVEC_WINDOW_CONFIGURATION
);
6398 data
->frame_cols
= FRAME_COLS (f
);
6399 data
->frame_lines
= FRAME_LINES (f
);
6400 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6401 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6402 data
->selected_frame
= selected_frame
;
6403 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6404 XSETBUFFER (data
->current_buffer
, current_buffer
);
6405 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6406 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6407 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6408 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6409 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6410 data
->saved_windows
= tem
;
6411 for (i
= 0; i
< n_windows
; i
++)
6412 XVECTOR (tem
)->contents
[i
]
6413 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6414 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6415 XSETWINDOW_CONFIGURATION (tem
, data
);
6419 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6421 doc
: /* Execute BODY, preserving window sizes and contents.
6422 Return the value of the last form in BODY.
6423 Restore which buffer appears in which window, where display starts,
6424 and the value of point and mark for each window.
6425 Also restore the choice of selected window.
6426 Also restore which buffer is current.
6427 Does not restore the value of point in current buffer.
6428 usage: (save-window-excursion BODY...) */)
6432 register Lisp_Object val
;
6433 register int count
= SPECPDL_INDEX ();
6435 record_unwind_protect (Fset_window_configuration
,
6436 Fcurrent_window_configuration (Qnil
));
6437 val
= Fprogn (args
);
6438 return unbind_to (count
, val
);
6443 /***********************************************************************
6445 ***********************************************************************/
6451 Lisp_Object tail
= Qnil
;
6452 Lisp_Object result
= Qnil
;
6459 if (!NILP (w
->hchild
))
6460 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6461 window_tree (XWINDOW (w
->hchild
))));
6462 else if (!NILP (w
->vchild
))
6463 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6464 window_tree (XWINDOW (w
->vchild
))));
6468 result
= tail
= Fcons (wn
, Qnil
);
6472 XSETCDR (tail
, Fcons (wn
, Qnil
));
6476 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6484 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6486 doc
: /* Return the window tree for frame FRAME.
6488 The return value is a list of the form (ROOT MINI), where ROOT
6489 represents the window tree of the frame's root window, and MINI
6490 is the frame's minibuffer window.
6492 If the root window is not split, ROOT is the root window itself.
6493 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6494 horizontal split, and t for a vertical split, EDGES gives the combined
6495 size and position of the subwindows in the split, and the rest of the
6496 elements are the subwindows in the split. Each of the subwindows may
6497 again be a window or a list representing a window split, and so on.
6498 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6500 If FRAME is nil or omitted, return information on the currently
6508 frame
= selected_frame
;
6510 CHECK_FRAME (frame
);
6513 if (!FRAME_LIVE_P (f
))
6516 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6520 /***********************************************************************
6522 ***********************************************************************/
6524 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6526 doc
: /* Set width of marginal areas of window WINDOW.
6527 If WINDOW is nil, set margins of the currently selected window.
6528 Second arg LEFT-WIDTH specifies the number of character cells to
6529 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6530 does the same for the right marginal area. A nil width parameter
6531 means no margin. */)
6532 (window
, left_width
, right_width
)
6533 Lisp_Object window
, left_width
, right_width
;
6535 struct window
*w
= decode_window (window
);
6537 /* Translate negative or zero widths to nil.
6538 Margins that are too wide have to be checked elsewhere. */
6540 if (!NILP (left_width
))
6542 CHECK_NUMBER (left_width
);
6543 if (XINT (left_width
) <= 0)
6547 if (!NILP (right_width
))
6549 CHECK_NUMBER (right_width
);
6550 if (XINT (right_width
) <= 0)
6554 if (!EQ (w
->left_margin_cols
, left_width
)
6555 || !EQ (w
->right_margin_cols
, right_width
))
6557 w
->left_margin_cols
= left_width
;
6558 w
->right_margin_cols
= right_width
;
6560 adjust_window_margins (w
);
6562 ++windows_or_buffers_changed
;
6563 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6570 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6572 doc
: /* Get width of marginal areas of window WINDOW.
6573 If WINDOW is omitted or nil, use the currently selected window.
6574 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6575 If a marginal area does not exist, its width will be returned
6580 struct window
*w
= decode_window (window
);
6581 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6586 /***********************************************************************
6588 ***********************************************************************/
6590 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6592 doc
: /* Set the fringe widths of window WINDOW.
6593 If WINDOW is nil, set the fringe widths of the currently selected
6595 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6596 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6597 fringe width. If a fringe width arg is nil, that means to use the
6598 frame's default fringe width. Default fringe widths can be set with
6599 the command `set-fringe-style'.
6600 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6601 outside of the display margins. By default, fringes are drawn between
6602 display marginal areas and the text area. */)
6603 (window
, left_width
, right_width
, outside_margins
)
6604 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6606 struct window
*w
= decode_window (window
);
6608 if (!NILP (left_width
))
6609 CHECK_NATNUM (left_width
);
6610 if (!NILP (right_width
))
6611 CHECK_NATNUM (right_width
);
6613 /* Do nothing on a tty. */
6614 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6615 && (!EQ (w
->left_fringe_width
, left_width
)
6616 || !EQ (w
->right_fringe_width
, right_width
)
6617 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6619 w
->left_fringe_width
= left_width
;
6620 w
->right_fringe_width
= right_width
;
6621 w
->fringes_outside_margins
= outside_margins
;
6623 adjust_window_margins (w
);
6625 clear_glyph_matrix (w
->current_matrix
);
6626 w
->window_end_valid
= Qnil
;
6628 ++windows_or_buffers_changed
;
6629 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6636 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6638 doc
: /* Get width of fringes of window WINDOW.
6639 If WINDOW is omitted or nil, use the currently selected window.
6640 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6644 struct window
*w
= decode_window (window
);
6646 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6647 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6648 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6649 ? Qt
: Qnil
), Qnil
)));
6654 /***********************************************************************
6656 ***********************************************************************/
6658 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6660 doc
: /* Set width and type of scroll bars of window WINDOW.
6661 If window is nil, set scroll bars of the currently selected window.
6662 Second parameter WIDTH specifies the pixel width for the scroll bar;
6663 this is automatically adjusted to a multiple of the frame column width.
6664 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6665 bar: left, right, or nil.
6666 If WIDTH is nil, use the frame's scroll-bar width.
6667 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6668 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6669 (window
, width
, vertical_type
, horizontal_type
)
6670 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6672 struct window
*w
= decode_window (window
);
6676 CHECK_NATNUM (width
);
6678 if (XINT (width
) == 0)
6679 vertical_type
= Qnil
;
6682 if (!(NILP (vertical_type
)
6683 || EQ (vertical_type
, Qleft
)
6684 || EQ (vertical_type
, Qright
)
6685 || EQ (vertical_type
, Qt
)))
6686 error ("Invalid type of vertical scroll bar");
6688 if (!EQ (w
->scroll_bar_width
, width
)
6689 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6691 w
->scroll_bar_width
= width
;
6692 w
->vertical_scroll_bar_type
= vertical_type
;
6694 adjust_window_margins (w
);
6696 clear_glyph_matrix (w
->current_matrix
);
6697 w
->window_end_valid
= Qnil
;
6699 ++windows_or_buffers_changed
;
6700 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6707 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6709 doc
: /* Get width and type of scroll bars of window WINDOW.
6710 If WINDOW is omitted or nil, use the currently selected window.
6711 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6712 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6717 struct window
*w
= decode_window (window
);
6718 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6719 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6720 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6721 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6722 Fcons (w
->vertical_scroll_bar_type
,
6723 Fcons (Qnil
, Qnil
))));
6728 /***********************************************************************
6730 ***********************************************************************/
6732 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6733 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6734 Use the selected window if WINDOW is nil or omitted.
6735 Normally, value is a multiple of the canonical character height of WINDOW;
6736 optional second arg PIXELS-P means value is measured in pixels. */)
6738 Lisp_Object window
, pixels_p
;
6745 window
= selected_window
;
6747 CHECK_WINDOW (window
);
6748 w
= XWINDOW (window
);
6749 f
= XFRAME (w
->frame
);
6751 if (FRAME_WINDOW_P (f
))
6752 result
= (NILP (pixels_p
)
6753 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6754 : make_number (-w
->vscroll
));
6756 result
= make_number (0);
6761 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6763 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6764 WINDOW nil means use the selected window. Normally, VSCROLL is a
6765 non-negative multiple of the canonical character height of WINDOW;
6766 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6767 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6768 corresponds to an integral number of pixels. The return value is the
6769 result of this rounding.
6770 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6771 (window
, vscroll
, pixels_p
)
6772 Lisp_Object window
, vscroll
, pixels_p
;
6778 window
= selected_window
;
6780 CHECK_WINDOW (window
);
6781 CHECK_NUMBER_OR_FLOAT (vscroll
);
6783 w
= XWINDOW (window
);
6784 f
= XFRAME (w
->frame
);
6786 if (FRAME_WINDOW_P (f
))
6788 int old_dy
= w
->vscroll
;
6790 w
->vscroll
= - (NILP (pixels_p
)
6791 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6792 : XFLOATINT (vscroll
));
6793 w
->vscroll
= min (w
->vscroll
, 0);
6795 if (w
->vscroll
!= old_dy
)
6797 /* Adjust glyph matrix of the frame if the virtual display
6798 area becomes larger than before. */
6799 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6802 /* Prevent redisplay shortcuts. */
6803 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6807 return Fwindow_vscroll (window
, pixels_p
);
6811 /* Call FN for all leaf windows on frame F. FN is called with the
6812 first argument being a pointer to the leaf window, and with
6813 additional argument USER_DATA. Stops when FN returns 0. */
6816 foreach_window (f
, fn
, user_data
)
6818 int (* fn
) P_ ((struct window
*, void *));
6821 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6822 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6823 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6827 /* Helper function for foreach_window. Call FN for all leaf windows
6828 reachable from W. FN is called with the first argument being a
6829 pointer to the leaf window, and with additional argument USER_DATA.
6830 Stop when FN returns 0. Value is 0 if stopped by FN. */
6833 foreach_window_1 (w
, fn
, user_data
)
6835 int (* fn
) P_ ((struct window
*, void *));
6840 for (cont
= 1; w
&& cont
;)
6842 if (!NILP (w
->hchild
))
6843 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6844 else if (!NILP (w
->vchild
))
6845 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6847 cont
= fn (w
, user_data
);
6849 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6856 /* Freeze or unfreeze the window start of W unless it is a
6857 mini-window or the selected window. FREEZE_P non-null means freeze
6858 the window start. */
6861 freeze_window_start (w
, freeze_p
)
6865 if (MINI_WINDOW_P (w
)
6866 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6867 && (w
== XWINDOW (selected_window
)
6868 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6869 && ! NILP (Vminibuf_scroll_window
)
6870 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6873 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6878 /* Freeze or unfreeze the window starts of all leaf windows on frame
6879 F, except the selected window and a mini-window. FREEZE_P non-zero
6880 means freeze the window start. */
6883 freeze_window_starts (f
, freeze_p
)
6887 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6891 /***********************************************************************
6893 ***********************************************************************/
6895 /* Return 1 if window configurations C1 and C2
6896 describe the same state of affairs. This is used by Fequal. */
6899 compare_window_configurations (c1
, c2
, ignore_positions
)
6901 int ignore_positions
;
6903 register struct save_window_data
*d1
, *d2
;
6904 struct Lisp_Vector
*sw1
, *sw2
;
6907 CHECK_WINDOW_CONFIGURATION (c1
);
6908 CHECK_WINDOW_CONFIGURATION (c2
);
6910 d1
= (struct save_window_data
*) XVECTOR (c1
);
6911 d2
= (struct save_window_data
*) XVECTOR (c2
);
6912 sw1
= XVECTOR (d1
->saved_windows
);
6913 sw2
= XVECTOR (d2
->saved_windows
);
6915 if (d1
->frame_cols
!= d2
->frame_cols
)
6917 if (d1
->frame_lines
!= d2
->frame_lines
)
6919 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
6921 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6923 /* Don't compare the current_window field directly.
6924 Instead see w1_is_current and w2_is_current, below. */
6925 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6927 if (! ignore_positions
)
6929 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6931 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6934 /* Don't compare the root_window field.
6935 We don't require the two configurations
6936 to use the same window object,
6937 and the two root windows must be equivalent
6938 if everything else compares equal. */
6939 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6942 /* Verify that the two confis have the same number of windows. */
6943 if (sw1
->size
!= sw2
->size
)
6946 for (i
= 0; i
< sw1
->size
; i
++)
6948 struct saved_window
*p1
, *p2
;
6949 int w1_is_current
, w2_is_current
;
6951 p1
= SAVED_WINDOW_N (sw1
, i
);
6952 p2
= SAVED_WINDOW_N (sw2
, i
);
6954 /* Verify that the current windows in the two
6955 configurations correspond to each other. */
6956 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6957 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6959 if (w1_is_current
!= w2_is_current
)
6962 /* Verify that the corresponding windows do match. */
6963 if (! EQ (p1
->buffer
, p2
->buffer
))
6965 if (! EQ (p1
->left_col
, p2
->left_col
))
6967 if (! EQ (p1
->top_line
, p2
->top_line
))
6969 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6971 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6973 if (! EQ (p1
->display_table
, p2
->display_table
))
6975 if (! EQ (p1
->parent
, p2
->parent
))
6977 if (! EQ (p1
->prev
, p2
->prev
))
6979 if (! ignore_positions
)
6981 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6983 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6985 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6987 if (NILP (Fequal (p1
->start
, p2
->start
)))
6989 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6991 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6994 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6996 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6998 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7000 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7002 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7004 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7006 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7013 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7014 Scompare_window_configurations
, 2, 2, 0,
7015 doc
: /* Compare two window configurations as regards the structure of windows.
7016 This function ignores details such as the values of point and mark
7017 and scrolling positions. */)
7021 if (compare_window_configurations (x
, y
, 1))
7029 struct frame
*f
= make_initial_frame ();
7030 XSETFRAME (selected_frame
, f
);
7031 Vterminal_frame
= selected_frame
;
7032 minibuf_window
= f
->minibuffer_window
;
7033 selected_window
= f
->selected_window
;
7034 last_nonminibuf_frame
= f
;
7036 window_initialized
= 1;
7042 Vwindow_list
= Qnil
;
7048 Qscroll_up
= intern ("scroll-up");
7049 staticpro (&Qscroll_up
);
7051 Qscroll_down
= intern ("scroll-down");
7052 staticpro (&Qscroll_down
);
7054 Qwindow_size_fixed
= intern ("window-size-fixed");
7055 staticpro (&Qwindow_size_fixed
);
7056 Fset (Qwindow_size_fixed
, Qnil
);
7058 staticpro (&Qwindow_configuration_change_hook
);
7059 Qwindow_configuration_change_hook
7060 = intern ("window-configuration-change-hook");
7062 Qwindowp
= intern ("windowp");
7063 staticpro (&Qwindowp
);
7065 Qwindow_configuration_p
= intern ("window-configuration-p");
7066 staticpro (&Qwindow_configuration_p
);
7068 Qwindow_live_p
= intern ("window-live-p");
7069 staticpro (&Qwindow_live_p
);
7071 Qdisplay_buffer
= intern ("display-buffer");
7072 staticpro (&Qdisplay_buffer
);
7074 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7075 staticpro (&Qtemp_buffer_show_hook
);
7077 staticpro (&Vwindow_list
);
7079 minibuf_selected_window
= Qnil
;
7080 staticpro (&minibuf_selected_window
);
7082 window_scroll_pixel_based_preserve_x
= -1;
7083 window_scroll_pixel_based_preserve_y
= -1;
7084 window_scroll_preserve_hpos
= -1;
7085 window_scroll_preserve_vpos
= -1;
7087 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7088 doc
: /* Non-nil means call as function to display a help buffer.
7089 The function is called with one argument, the buffer to be displayed.
7090 Used by `with-output-to-temp-buffer'.
7091 If this function is used, then it must do the entire job of showing
7092 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7093 Vtemp_buffer_show_function
= Qnil
;
7095 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7096 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7097 Vminibuf_scroll_window
= Qnil
;
7099 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7100 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7101 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7102 is displayed in the `mode-line' face. */);
7103 mode_line_in_non_selected_windows
= 1;
7105 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7106 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7107 Vother_window_scroll_buffer
= Qnil
;
7109 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7110 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7111 auto_window_vscroll_p
= 1;
7113 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7114 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7115 next_screen_context_lines
= 2;
7117 DEFVAR_INT ("window-min-height", &window_min_height
,
7118 doc
: /* Allow deleting windows less than this tall.
7119 The value is measured in line units. If a window wants a modeline it
7120 is counted as one line.
7122 Emacs honors settings of this variable when enlarging or shrinking
7123 windows vertically. A value less than 1 is invalid. */);
7124 window_min_height
= 4;
7126 DEFVAR_INT ("window-min-width", &window_min_width
,
7127 doc
: /* Allow deleting windows less than this wide.
7128 The value is measured in characters and includes any fringes or
7131 Emacs honors settings of this variable when enlarging or shrinking
7132 windows horizontally. A value less than 2 is invalid. */);
7133 window_min_width
= 10;
7135 DEFVAR_LISP ("scroll-preserve-screen-position",
7136 &Vscroll_preserve_screen_position
,
7137 doc
: /* *Controls if scroll commands move point to keep its screen position unchanged.
7138 A value of nil means point does not keep its screen position except
7139 at the scroll margin or window boundary respectively.
7140 A value of t means point keeps its screen position if the scroll
7141 command moved it vertically out of the window, e.g. when scrolling
7143 Any other value means point always keeps its screen position. */);
7144 Vscroll_preserve_screen_position
= Qnil
;
7146 DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type
,
7147 doc
: /* Type of marker to use for `window-point'. */);
7148 Vwindow_point_insertion_type
= Qnil
;
7150 DEFVAR_LISP ("window-configuration-change-hook",
7151 &Vwindow_configuration_change_hook
,
7152 doc
: /* Functions to call when window configuration changes.
7153 The buffer-local part is run once per window, with the relevant window
7154 selected; while the global part is run only once for the modified frame,
7155 with the relevant frame selected. */);
7156 Vwindow_configuration_change_hook
= Qnil
;
7158 defsubr (&Sselected_window
);
7159 defsubr (&Sminibuffer_window
);
7160 defsubr (&Swindow_minibuffer_p
);
7161 defsubr (&Swindowp
);
7162 defsubr (&Swindow_live_p
);
7163 defsubr (&Spos_visible_in_window_p
);
7164 defsubr (&Swindow_line_height
);
7165 defsubr (&Swindow_buffer
);
7166 defsubr (&Swindow_height
);
7167 defsubr (&Swindow_width
);
7168 defsubr (&Swindow_full_width_p
);
7169 defsubr (&Swindow_hscroll
);
7170 defsubr (&Sset_window_hscroll
);
7171 defsubr (&Swindow_redisplay_end_trigger
);
7172 defsubr (&Sset_window_redisplay_end_trigger
);
7173 defsubr (&Swindow_edges
);
7174 defsubr (&Swindow_pixel_edges
);
7175 defsubr (&Swindow_inside_edges
);
7176 defsubr (&Swindow_inside_pixel_edges
);
7177 defsubr (&Scoordinates_in_window_p
);
7178 defsubr (&Swindow_at
);
7179 defsubr (&Swindow_point
);
7180 defsubr (&Swindow_start
);
7181 defsubr (&Swindow_end
);
7182 defsubr (&Sset_window_point
);
7183 defsubr (&Sset_window_start
);
7184 defsubr (&Swindow_dedicated_p
);
7185 defsubr (&Sset_window_dedicated_p
);
7186 defsubr (&Swindow_display_table
);
7187 defsubr (&Sset_window_display_table
);
7188 defsubr (&Snext_window
);
7189 defsubr (&Sprevious_window
);
7190 defsubr (&Sother_window
);
7191 defsubr (&Sget_lru_window
);
7192 defsubr (&Sget_largest_window
);
7193 defsubr (&Sget_buffer_window
);
7194 defsubr (&Sdelete_other_windows
);
7195 defsubr (&Sdelete_windows_on
);
7196 defsubr (&Sreplace_buffer_in_windows
);
7197 defsubr (&Sdelete_window
);
7198 defsubr (&Sset_window_buffer
);
7199 defsubr (&Sselect_window
);
7200 defsubr (&Sforce_window_update
);
7201 defsubr (&Ssplit_window
);
7202 defsubr (&Senlarge_window
);
7203 defsubr (&Sshrink_window
);
7204 defsubr (&Sadjust_window_trailing_edge
);
7205 defsubr (&Sscroll_up
);
7206 defsubr (&Sscroll_down
);
7207 defsubr (&Sscroll_left
);
7208 defsubr (&Sscroll_right
);
7209 defsubr (&Sother_window_for_scrolling
);
7210 defsubr (&Sscroll_other_window
);
7211 defsubr (&Sminibuffer_selected_window
);
7212 defsubr (&Srecenter
);
7213 defsubr (&Swindow_text_height
);
7214 defsubr (&Smove_to_window_line
);
7215 defsubr (&Swindow_configuration_p
);
7216 defsubr (&Swindow_configuration_frame
);
7217 defsubr (&Sset_window_configuration
);
7218 defsubr (&Scurrent_window_configuration
);
7219 defsubr (&Ssave_window_excursion
);
7220 defsubr (&Swindow_tree
);
7221 defsubr (&Sset_window_margins
);
7222 defsubr (&Swindow_margins
);
7223 defsubr (&Sset_window_fringes
);
7224 defsubr (&Swindow_fringes
);
7225 defsubr (&Sset_window_scroll_bars
);
7226 defsubr (&Swindow_scroll_bars
);
7227 defsubr (&Swindow_vscroll
);
7228 defsubr (&Sset_window_vscroll
);
7229 defsubr (&Scompare_window_configurations
);
7230 defsubr (&Swindow_list
);
7231 defsubr (&Swindow_parameters
);
7232 defsubr (&Swindow_parameter
);
7233 defsubr (&Sset_window_parameter
);
7240 initial_define_key (control_x_map
, '1', "delete-other-windows");
7241 initial_define_key (control_x_map
, '2', "split-window");
7242 initial_define_key (control_x_map
, '0', "delete-window");
7243 initial_define_key (control_x_map
, 'o', "other-window");
7244 initial_define_key (control_x_map
, '^', "enlarge-window");
7245 initial_define_key (control_x_map
, '<', "scroll-left");
7246 initial_define_key (control_x_map
, '>', "scroll-right");
7248 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7249 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7250 initial_define_key (meta_map
, 'v', "scroll-down");
7252 initial_define_key (global_map
, Ctl('L'), "recenter");
7253 initial_define_key (meta_map
, 'r', "move-to-window-line");
7256 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7257 (do not change this comment) */