X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/940f53e5f88b256855660f7ce6cba8b4ac1a5cf5..2a0bd758b7c45138c8343f8a591ab8c77401b52b:/src/window.c diff --git a/src/window.c b/src/window.c index d42ff11d7d..ed4fc9c8ae 100644 --- a/src/window.c +++ b/src/window.c @@ -1,7 +1,7 @@ /* Window creation, deletion and examination for GNU Emacs. Does not include redisplay. - Copyright (C) 1985,86,87, 1993,94,95,96,97,98, 2000,01,02,03,04 - Free Software Foundation, Inc. + Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000, + 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -17,8 +17,8 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs; see the file COPYING. If not, write to -the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ #include #include "lisp.h" @@ -79,10 +79,6 @@ static int foreach_window_1 P_ ((struct window *, void *)); static Lisp_Object window_list_1 P_ ((Lisp_Object, Lisp_Object, Lisp_Object)); -/* The value of `window-size-fixed'. */ - -int window_size_fixed; - /* This is the window in which the terminal's cursor should be left when nothing is being done with it. This must always be a leaf window, and its buffer is selected by @@ -124,6 +120,11 @@ Lisp_Object Vother_window_scroll_buffer; Lisp_Object Vtemp_buffer_show_function; +/* Non-zero means line and page scrolling on tall lines (with images) + does partial scrolling by modifying window-vscroll. */ + +int auto_window_vscroll_p; + /* Non-zero means to use mode-line-inactive face in all windows but the selected-window and the minibuffer-scroll-window when the minibuffer is active. */ @@ -281,7 +282,6 @@ make_window () p->fringes_outside_margins = Qnil; p->scroll_bar_width = Qnil; p->vertical_scroll_bar_type = Qt; - p->overlay_arrow_bitmap = 0; Vwindow_list = Qnil; return val; @@ -328,9 +328,10 @@ If POS is only out of view because of horizontal scrolling, return non-nil. POS defaults to point in WINDOW; WINDOW defaults to the selected window. If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil, -return value is a list (X Y FULLY) where X and Y are the pixel coordinates -relative to the top left corner of the window, and FULLY is t if the -character after POS is fully visible and nil otherwise. */) +return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates +relative to the top left corner of the window. PARTIAL is nil if the character +after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP +and RBOT are the number of pixels invisible at the top and bottom of the row. */) (pos, window, partially) Lisp_Object pos, window, partially; { @@ -339,7 +340,7 @@ character after POS is fully visible and nil otherwise. */) register struct buffer *buf; struct text_pos top; Lisp_Object in_window = Qnil; - int fully_p = 1; + int rtop, rbot, fully_p = 1; int x, y; w = decode_window (window); @@ -362,14 +363,17 @@ character after POS is fully visible and nil otherwise. */) && posint <= BUF_ZV (buf) && CHARPOS (top) >= BUF_BEGV (buf) && CHARPOS (top) <= BUF_ZV (buf) - && pos_visible_p (w, posint, &fully_p, &x, &y, NILP (partially)) - && (!NILP (partially) || fully_p)) + && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, NILP (partially)) + && (fully_p = !rtop && !rbot, (!NILP (partially) || fully_p))) in_window = Qt; if (!NILP (in_window) && !NILP (partially)) in_window = Fcons (make_number (x), Fcons (make_number (y), - Fcons (fully_p ? Qt : Qnil, Qnil))); + Fcons ((fully_p ? Qnil + : Fcons (make_number (rtop), + make_number (rbot))), + Qnil))); return in_window; } @@ -540,7 +544,7 @@ display margins, fringes, header line, and/or mode line. */) + WINDOW_LEFT_FRINGE_COLS (w)), make_number (WINDOW_TOP_EDGE_LINE (w) + WINDOW_HEADER_LINE_LINES (w)), - make_number (WINDOW_RIGHT_EDGE_COL (w) + make_number (WINDOW_BOX_RIGHT_EDGE_COL (w) - WINDOW_RIGHT_MARGIN_COLS (w) - WINDOW_RIGHT_FRINGE_COLS (w)), make_number (WINDOW_BOTTOM_EDGE_LINE (w) @@ -564,7 +568,7 @@ display margins, fringes, header line, and/or mode line. */) + WINDOW_LEFT_FRINGE_WIDTH (w)), make_number (WINDOW_TOP_EDGE_Y (w) + WINDOW_HEADER_LINE_HEIGHT (w)), - make_number (WINDOW_RIGHT_EDGE_X (w) + make_number (WINDOW_BOX_RIGHT_EDGE_X (w) - WINDOW_RIGHT_MARGIN_WIDTH (w) - WINDOW_RIGHT_FRINGE_WIDTH (w)), make_number (WINDOW_BOTTOM_EDGE_Y (w) @@ -1448,8 +1452,10 @@ delete_window (window) tem = par->hchild; if (NILP (tem)) tem = par->vchild; - if (NILP (XWINDOW (tem)->next)) + if (NILP (XWINDOW (tem)->next)) { replace_window (parent, tem); + par = XWINDOW (tem); + } /* Since we may be deleting combination windows, we must make sure that not only p but all its children have been marked as deleted. */ @@ -1461,6 +1467,51 @@ delete_window (window) /* Mark this window as deleted. */ p->buffer = p->hchild = p->vchild = Qnil; + if (! NILP (par->parent)) + par = XWINDOW (par->parent); + + /* Check if we have a v/hchild with a v/hchild. In that case remove + one of them. */ + + if (! NILP (par->vchild) && ! NILP (XWINDOW (par->vchild)->vchild)) + { + p = XWINDOW (par->vchild); + par->vchild = p->vchild; + tem = p->vchild; + } + else if (! NILP (par->hchild) && ! NILP (XWINDOW (par->hchild)->hchild)) + { + p = XWINDOW (par->hchild); + par->hchild = p->hchild; + tem = p->hchild; + } + else + p = 0; + + if (p) + { + while (! NILP (tem)) { + XWINDOW (tem)->parent = p->parent; + if (NILP (XWINDOW (tem)->next)) + break; + tem = XWINDOW (tem)->next; + } + if (! NILP (tem)) { + /* The next of the v/hchild we are removing is now the next of the + last child for the v/hchild: + Before v/hchild -> v/hchild -> next1 -> next2 + | + -> next3 + After: v/hchild -> next1 -> next2 -> next3 + */ + XWINDOW (tem)->next = p->next; + if (! NILP (p->next)) + XWINDOW (p->next)->prev = tem; + } + p->next = p->prev = p->vchild = p->hchild = p->buffer = Qnil; + } + + /* Adjust glyph matrices. */ adjust_glyphs (f); UNBLOCK_INPUT; @@ -3162,6 +3213,9 @@ selects the buffer of the selected window before each command. */) if (EQ (window, selected_window)) return window; + /* Store the current buffer's actual point into the + old selected window. It belongs to that window, + and when the window is not selected, must be in the window. */ if (!NILP (selected_window)) { ow = XWINDOW (selected_window); @@ -3180,7 +3234,7 @@ selects the buffer of the selected window before each command. */) so that FRAME_FOCUS_FRAME is moved appropriately as we move around in the state where a minibuffer in a separate frame is active. */ - Fselect_frame (WINDOW_FRAME (w), Qnil); + Fselect_frame (WINDOW_FRAME (w)); } else sf->selected_window = window; @@ -3256,9 +3310,10 @@ display_buffer_1 (window) DEFUN ("special-display-p", Fspecial_display_p, Sspecial_display_p, 1, 1, 0, doc: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame. -If the value is t, a frame would be created for that buffer -using the default frame parameters. If the value is a list, -it is a list of frame parameters that would be used +If the value is t, `display-buffer' or `pop-to-buffer' would create a +special frame for that buffer using the default frame parameters. + +If the value is a list, it is a list of frame parameters that would be used to make a frame for that buffer. The variables `special-display-buffer-names' and `special-display-regexps' control this. */) @@ -3292,7 +3347,9 @@ and `special-display-regexps' control this. */) } DEFUN ("same-window-p", Fsame_window_p, Ssame_window_p, 1, 1, 0, - doc: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window. + doc: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window. +More precisely, if `display-buffer' or `pop-to-buffer' would display +that buffer in the selected window rather than (as usual) in some other window. See `same-window-buffer-names' and `same-window-regexps'. */) (buffer_name) Lisp_Object buffer_name; @@ -4123,7 +4180,7 @@ enlarge_window (window, delta, widthflag, preserve_before) The number of children n equals the number of resizable children of this window + 1 because we know window itself - is resizable (otherwise we would have signalled an error. */ + is resizable (otherwise we would have signalled an error). */ struct window *w = XWINDOW (window); Lisp_Object s; @@ -4564,6 +4621,33 @@ window_scroll_pixel_based (window, n, whole, noerror) start = it.current.pos; } + else if (auto_window_vscroll_p) + { + if (tem = XCAR (XCDR (XCDR (tem))), CONSP (tem)) + { + int px; + int dy = WINDOW_FRAME_LINE_HEIGHT (w); + if (whole) + dy = max ((window_box_height (w) + - next_screen_context_lines * dy), + dy); + dy *= n; + + if (n < 0 && (px = XINT (XCAR (tem))) > 0) + { + px = max (0, -w->vscroll - min (px, -dy)); + Fset_window_vscroll (window, make_number (px), Qt); + return; + } + if (n > 0 && (px = XINT (XCDR (tem))) > 0) + { + px = max (0, -w->vscroll + min (px, dy)); + Fset_window_vscroll (window, make_number (px), Qt); + return; + } + } + Fset_window_vscroll (window, make_number (0), Qt); + } /* If scroll_preserve_screen_position is non-nil, we try to set point in the same window line as it is now, so get that line. */ @@ -4581,18 +4665,34 @@ window_scroll_pixel_based (window, n, whole, noerror) start_display (&it, w, start); if (whole) { - int screen_full = (window_box_height (w) - - next_screen_context_lines * FRAME_LINE_HEIGHT (it.f)); - int dy = n * screen_full; + int start_pos = IT_CHARPOS (it); + int dy = WINDOW_FRAME_LINE_HEIGHT (w); + dy = max ((window_box_height (w) + - next_screen_context_lines * dy), + dy) * n; /* Note that move_it_vertically always moves the iterator to the start of a line. So, if the last line doesn't have a newline, we would end up at the start of the line ending at ZV. */ if (dy <= 0) - move_it_vertically_backward (&it, -dy); + { + move_it_vertically_backward (&it, -dy); + /* Ensure we actually does move, e.g. in case we are currently + looking at an image that is taller that the window height. */ + while (start_pos == IT_CHARPOS (it) + && start_pos > BEGV) + move_it_by_lines (&it, -1, 1); + } else if (dy > 0) - move_it_to (&it, ZV, -1, it.current_y + dy, -1, - MOVE_TO_POS | MOVE_TO_Y); + { + move_it_to (&it, ZV, -1, it.current_y + dy, -1, + MOVE_TO_POS | MOVE_TO_Y); + /* Ensure we actually does move, e.g. in case we are currently + looking at an image that is taller that the window height. */ + while (start_pos == IT_CHARPOS (it) + && start_pos < ZV) + move_it_by_lines (&it, 1, 1); + } } else move_it_by_lines (&it, n, 1); @@ -4683,12 +4783,15 @@ window_scroll_pixel_based (window, n, whole, noerror) /* We moved the window start towards ZV, so PT may be now in the scroll margin at the top. */ move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS); - if (IT_CHARPOS (it) == PT && it.current_y >= this_scroll_margin) + if (IT_CHARPOS (it) == PT && it.current_y >= this_scroll_margin + && (NILP (Vscroll_preserve_screen_position) + || EQ (Vscroll_preserve_screen_position, Qt))) /* We found PT at a legitimate height. Leave it alone. */ ; else if (preserve_y >= 0) { - /* If we have a header line, take account of it. */ + /* If we have a header line, take account of it. + This is necessary because we set it.current_y to 0, above. */ if (WINDOW_WANTS_HEADER_LINE_P (w)) preserve_y -= CURRENT_HEADER_LINE_HEIGHT (w); @@ -4710,6 +4813,7 @@ window_scroll_pixel_based (window, n, whole, noerror) else if (n < 0) { int charpos, bytepos; + int partial_p; /* Save our position, for the preserve_y case. */ charpos = IT_CHARPOS (it); @@ -4718,33 +4822,48 @@ window_scroll_pixel_based (window, n, whole, noerror) /* We moved the window start towards BEGV, so PT may be now in the scroll margin at the bottom. */ move_it_to (&it, PT, -1, - it.last_visible_y - this_scroll_margin - 1, -1, + (it.last_visible_y - CURRENT_HEADER_LINE_HEIGHT (w) + - this_scroll_margin - 1), + -1, MOVE_TO_POS | MOVE_TO_Y); - if (IT_CHARPOS (it) == PT) + /* Save our position, in case it's correct. */ + charpos = IT_CHARPOS (it); + bytepos = IT_BYTEPOS (it); + + /* See if point is on a partially visible line at the end. */ + if (it.what == IT_EOB) + partial_p = it.current_y + it.ascent + it.descent > it.last_visible_y; + else + { + move_it_by_lines (&it, 1, 1); + partial_p = it.current_y > it.last_visible_y; + } + + if (charpos == PT && !partial_p + && (NILP (Vscroll_preserve_screen_position) + || EQ (Vscroll_preserve_screen_position, Qt))) /* We found PT before we found the display margin, so PT is ok. */ ; else if (preserve_y >= 0) { SET_TEXT_POS_FROM_MARKER (start, w->start); start_display (&it, w, start); +#if 0 /* It's wrong to subtract this here + because we called start_display again + and did not alter it.current_y this time. */ + /* If we have a header line, take account of it. */ if (WINDOW_WANTS_HEADER_LINE_P (w)) preserve_y -= CURRENT_HEADER_LINE_HEIGHT (w); +#endif move_it_to (&it, -1, -1, preserve_y, -1, MOVE_TO_Y); SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it)); } else { - /* Save our position, in case it's correct. */ - charpos = IT_CHARPOS (it); - bytepos = IT_BYTEPOS (it); - - /* See if point is on a partially visible line at the end. */ - move_it_by_lines (&it, 1, 1); - - if (it.current_y > it.last_visible_y) + if (partial_p) /* The last line was only partially visible, so back up two lines to make sure we're on a fully visible line. */ { @@ -4838,7 +4957,8 @@ window_scroll_line_based (window, n, whole, noerror) the window-scroll-functions. */ w->force_start = Qt; - if (whole && !NILP (Vscroll_preserve_screen_position)) + if (!NILP (Vscroll_preserve_screen_position) + && (whole || !EQ (Vscroll_preserve_screen_position, Qt))) { SET_PT_BOTH (pos, pos_byte); Fvertical_motion (make_number (original_vpos), window); @@ -5213,6 +5333,8 @@ and redisplay normally--don't erase and redraw the frame. */) struct buffer *obuf = current_buffer; int center_p = 0; int charpos, bytepos; + int iarg; + int this_scroll_margin; /* If redisplay is suppressed due to an error, try again. */ obuf->display_error_modiff = 0; @@ -5235,10 +5357,17 @@ and redisplay normally--don't erase and redraw the frame. */) { arg = Fprefix_numeric_value (arg); CHECK_NUMBER (arg); + iarg = XINT (arg); } set_buffer_internal (buf); + /* Do this after making BUF current + in case scroll_margin is buffer-local. */ + this_scroll_margin = max (0, scroll_margin); + this_scroll_margin = min (this_scroll_margin, + XFASTINT (w->total_lines) / 4); + /* Handle centering on a graphical frame specially. Such frames can have variable-height lines and centering point on the basis of line counts would lead to strange effects. */ @@ -5255,14 +5384,16 @@ and redisplay normally--don't erase and redraw the frame. */) charpos = IT_CHARPOS (it); bytepos = IT_BYTEPOS (it); } - else if (XINT (arg) < 0) + else if (iarg < 0) { struct it it; struct text_pos pt; - int nlines = - XINT (arg); + int nlines = -iarg; int extra_line_spacing; int h = window_box_height (w); + iarg = - max (-iarg, this_scroll_margin); + SET_TEXT_POS (pt, PT, PT_BYTE); start_display (&it, w, pt); @@ -5321,7 +5452,10 @@ and redisplay normally--don't erase and redraw the frame. */) else { struct position pos; - pos = *vmotion (PT, - XINT (arg), w); + + iarg = max (iarg, this_scroll_margin); + + pos = *vmotion (PT, -iarg, w); charpos = pos.bufpos; bytepos = pos.bytepos; } @@ -5332,11 +5466,15 @@ and redisplay normally--don't erase and redraw the frame. */) int ht = window_internal_height (w); if (center_p) - arg = make_number (ht / 2); - else if (XINT (arg) < 0) - arg = make_number (XINT (arg) + ht); + iarg = ht / 2; + else if (iarg < 0) + iarg += ht; + + /* Don't let it get into the margin at either top or bottom. */ + iarg = max (iarg, this_scroll_margin); + iarg = min (iarg, ht - this_scroll_margin - 1); - pos = *vmotion (PT, - XINT (arg), w); + pos = *vmotion (PT, - iarg, w); charpos = pos.bufpos; bytepos = pos.bytepos; } @@ -5385,6 +5523,9 @@ zero means top of window, negative means relative to bottom of window. */) struct window *w = XWINDOW (selected_window); int lines, start; Lisp_Object window; +#if 0 + int this_scroll_margin; +#endif window = selected_window; start = marker_position (w->start); @@ -5400,13 +5541,33 @@ zero means top of window, negative means relative to bottom of window. */) Fgoto_char (w->start); lines = displayed_window_lines (w); + +#if 0 + this_scroll_margin = max (0, scroll_margin); + this_scroll_margin = min (this_scroll_margin, lines / 4); +#endif + if (NILP (arg)) XSETFASTINT (arg, lines / 2); else { - arg = Fprefix_numeric_value (arg); - if (XINT (arg) < 0) - XSETINT (arg, XINT (arg) + lines); + int iarg = XINT (Fprefix_numeric_value (arg)); + + if (iarg < 0) + iarg = iarg + lines; + +#if 0 /* This code would prevent move-to-window-line from moving point + to a place inside the scroll margins (which would cause the + next redisplay to scroll). I wrote this code, but then concluded + it is probably better not to install it. However, it is here + inside #if 0 so as not to lose it. -- rms. */ + + /* Don't let it get into the margin at either top or bottom. */ + iarg = max (iarg, this_scroll_margin); + iarg = min (iarg, lines - this_scroll_margin - 1); +#endif + + arg = make_number (iarg); } /* Skip past a partially visible first line. */ @@ -5526,7 +5687,20 @@ the return value is nil. Otherwise the value is t. */) if (XBUFFER (new_current_buffer) == current_buffer) old_point = PT; else - old_point = BUF_PT (XBUFFER (new_current_buffer)); + /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of + point in new_current_buffer as of the last time this buffer was + used. This can be non-deterministic since it can be changed by + things like jit-lock by mere temporary selection of some random + window that happens to show this buffer. + So if possible we want this arbitrary choice of "which point" to + be the one from the to-be-selected-window so as to prevent this + window's cursor from being copied from another window. */ + if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer) + /* If current_window = selected_window, its point is in BUF_PT. */ + && !EQ (selected_window, data->current_window)) + old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos; + else + old_point = BUF_PT (XBUFFER (new_current_buffer)); } frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame; @@ -5571,8 +5745,9 @@ the return value is nil. Otherwise the value is t. */) #endif #endif - /* "Swap out" point from the selected window - into its buffer. We do this now, before + /* "Swap out" point from the selected window's buffer + into the window itself. (Normally the pointm of the selected + window holds garbage.) We do this now, before restoring the window contents, and prevent it from being done later on when we select a new window. */ if (! NILP (XWINDOW (selected_window)->buffer)) @@ -5722,10 +5897,11 @@ the return value is nil. Otherwise the value is t. */) FRAME_ROOT_WINDOW (f) = data->root_window; /* Prevent "swapping out point" in the old selected window using the buffer that has been restored into it. - Use the point value from the beginning of this function - since unshow_buffer (called from delete_all_subwindows) - could have altered it. */ + We already swapped out point that from that window's old buffer. */ selected_window = Qnil; + + /* Arrange *not* to restore point in the buffer that was + current when the window configuration was saved. */ if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)) set_marker_restricted (XWINDOW (data->current_window)->pointm, make_number (old_point), @@ -6329,13 +6505,16 @@ If PIXELS-P is non-nil, the return value is VSCROLL. */) : XFLOATINT (vscroll)); w->vscroll = min (w->vscroll, 0); - /* Adjust glyph matrix of the frame if the virtual display - area becomes larger than before. */ - if (w->vscroll < 0 && w->vscroll < old_dy) - adjust_glyphs (f); + if (w->vscroll != old_dy) + { + /* Adjust glyph matrix of the frame if the virtual display + area becomes larger than before. */ + if (w->vscroll < 0 && w->vscroll < old_dy) + adjust_glyphs (f); - /* Prevent redisplay shortcuts. */ - XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1; + /* Prevent redisplay shortcuts. */ + XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1; + } } return Fwindow_vscroll (window, pixels_p); @@ -6584,6 +6763,7 @@ syms_of_window () { Qwindow_size_fixed = intern ("window-size-fixed"); staticpro (&Qwindow_size_fixed); + Fset (Qwindow_size_fixed, Qnil); staticpro (&Qwindow_configuration_change_hook); Qwindow_configuration_change_hook @@ -6647,6 +6827,10 @@ is displayed in the `mode-line' face. */); doc: /* *Non-nil means `display-buffer' should make a separate frame. */); pop_up_frames = 0; + DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p, + doc: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */); + auto_window_vscroll_p = 1; + DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames, doc: /* *Non-nil means `display-buffer' should reuse frames. If the buffer in question is already displayed in a frame, raise that frame. */); @@ -6662,7 +6846,8 @@ where `pop-up-frame-alist' would hold the default frame parameters. */); DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names, doc: /* *List of buffer names that should have their own special frames. -Displaying a buffer whose name is in this list makes a special frame for it +Displaying a buffer with `display-buffer' or `pop-to-buffer', +if its name is in this list, makes a special frame for it using `special-display-function'. See also `special-display-regexps'. An element of the list can be a list instead of just a string. @@ -6687,9 +6872,9 @@ Those variables take precedence over this one. */); DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps, doc: /* *List of regexps saying which buffers should have their own special frames. -If a buffer name matches one of these regexps, it gets its own frame. -Displaying a buffer whose name is in this list makes a special frame for it -using `special-display-function'. +When displaying a buffer with `display-buffer' or `pop-to-buffer', +if any regexp in this list matches the buffer name, it makes a +special frame for the buffer by calling `special-display-function'. An element of the list can be a list instead of just a string. There are two ways to use a list as an element: @@ -6777,9 +6962,13 @@ If there is only one window, it is split regardless of this value. */); DEFVAR_LISP ("scroll-preserve-screen-position", &Vscroll_preserve_screen_position, - doc: /* *Non-nil means scroll commands move point to keep its screen line unchanged. -This is only when it is impossible to keep point fixed and still -scroll as specified. */); + doc: /* *Controls if scroll commands move point to keep its screen line unchanged. +A value of nil means point does not keep its screen position except +at the scroll margin or window boundary respectively. +A value of t means point keeps its screen position if the scroll +command moved it vertically out of the window, e.g. when scrolling +by full screens. +Any other value means point always keeps its screen position. */); Vscroll_preserve_screen_position = Qnil; DEFVAR_LISP ("window-configuration-change-hook", @@ -6788,16 +6977,6 @@ scroll as specified. */); The selected frame is the one whose configuration has changed. */); Vwindow_configuration_change_hook = Qnil; - DEFVAR_BOOL ("window-size-fixed", &window_size_fixed, - doc: /* Non-nil in a buffer means windows displaying the buffer are fixed-size. -If the value is`height', then only the window's height is fixed. -If the value is `width', then only the window's width is fixed. -Any other non-nil value fixes both the width and the height. -Emacs won't change the size of any window displaying that buffer, -unless you explicitly change the size, or Emacs has no other choice. */); - Fmake_variable_buffer_local (Qwindow_size_fixed); - window_size_fixed = 0; - defsubr (&Sselected_window); defsubr (&Sminibuffer_window); defsubr (&Swindow_minibuffer_p);