/* Window creation, deletion and examination for GNU Emacs.
Does not include redisplay.
- Copyright (C) 1985,86,87,93,94,95,96,97,1998,2000
+ Copyright (C) 1985,86,87,93,94,95,96,97,1998,2000, 2001, 2002
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "lisp.h"
#include "buffer.h"
#include "keyboard.h"
+#include "keymap.h"
#include "frame.h"
#include "window.h"
#include "commands.h"
#ifdef MSDOS
#include "msdos.h"
#endif
-#ifdef macintosh
+#ifdef MAC_OS
#include "macterm.h"
#endif
-#ifndef max
-#define max(a, b) ((a) < (b) ? (b) : (a))
-#endif
+/* Values returned from coordinates_in_window. */
+
+enum window_part
+{
+ ON_NOTHING,
+ ON_TEXT,
+ ON_MODE_LINE,
+ ON_VERTICAL_BORDER,
+ ON_HEADER_LINE,
+ ON_LEFT_FRINGE,
+ ON_RIGHT_FRINGE,
+ ON_LEFT_MARGIN,
+ ON_RIGHT_MARGIN
+};
Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configuration_p;
-Lisp_Object Qwindow_size_fixed, Qleft_bitmap_area, Qright_bitmap_area;
+Lisp_Object Qwindow_size_fixed;
+extern Lisp_Object Qleft_margin, Qright_margin;
extern Lisp_Object Qheight, Qwidth;
+static int displayed_window_lines P_ ((struct window *));
static struct window *decode_window P_ ((Lisp_Object));
static Lisp_Object select_window_1 P_ ((Lisp_Object, int));
static int count_windows P_ ((struct window *));
static void size_window P_ ((Lisp_Object, int, int, int));
static int freeze_window_start P_ ((struct window *, void *));
static int window_fixed_size_p P_ ((struct window *, int, int));
-static void enlarge_window P_ ((Lisp_Object, int, int));
+static void enlarge_window P_ ((Lisp_Object, int, int, int));
static Lisp_Object window_list P_ ((void));
static int add_window_to_list P_ ((struct window *, void *));
static int candidate_window_p P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
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
Lisp_Object minibuf_window;
+/* Non-nil means it is the window whose mode line should be
+ shown as the selected window when the minibuffer is selected. */
+
+Lisp_Object minibuf_selected_window;
+
/* Non-nil means it is the window for C-M-v to scroll
when the mini-buffer is selected. */
Lisp_Object Vtemp_buffer_show_function;
+/* 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. */
+int mode_line_in_non_selected_windows;
+
/* If a window gets smaller than either of these, it is removed. */
-int window_min_height;
-int window_min_width;
+EMACS_INT window_min_height;
+EMACS_INT window_min_width;
/* Nonzero implies Fdisplay_buffer should create windows. */
/* Fdisplay_buffer always splits the largest window
if that window is more than this high. */
-int split_height_threshold;
+EMACS_INT split_height_threshold;
/* Number of lines of continuity in scrolling by screenfuls. */
-int next_screen_context_lines;
+EMACS_INT next_screen_context_lines;
/* Incremented for each window created. */
static int inhibit_frame_unsplittable;
#endif /* 0 */
-#define min(a, b) ((a) < (b) ? (a) : (b))
-
-extern int scroll_margin;
+extern EMACS_INT scroll_margin;
extern Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
\f
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
- "Returns t if OBJECT is a window.")
- (object)
+ doc: /* Returns t if OBJECT is a window. */)
+ (object)
Lisp_Object object;
{
return WINDOWP (object) ? Qt : Qnil;
}
DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
- "Returns t if OBJECT is a window which is currently visible.")
+ doc: /* Returns t if OBJECT is a window which is currently visible. */)
(object)
Lisp_Object object;
{
- return (WINDOWP (object) && ! NILP (XWINDOW (object)->buffer) ? Qt : Qnil);
+ return WINDOW_LIVE_P (object) ? Qt : Qnil;
}
Lisp_Object
{
Lisp_Object val;
register struct window *p;
- register struct Lisp_Vector *vec;
- int i;
- vec = allocate_vectorlike ((EMACS_INT) VECSIZE (struct window));
- for (i = 0; i < VECSIZE (struct window); i++)
- vec->contents[i] = Qnil;
- vec->size = VECSIZE (struct window);
- p = (struct window *) vec;
+ p = allocate_window ();
XSETFASTINT (p->sequence_number, ++sequence_number);
XSETFASTINT (p->left, 0);
XSETFASTINT (p->top, 0);
XSETFASTINT (p->height, 0);
XSETFASTINT (p->width, 0);
XSETFASTINT (p->hscroll, 0);
+ XSETFASTINT (p->min_hscroll, 0);
p->orig_top = p->orig_height = Qnil;
p->start = Fmake_marker ();
p->pointm = Fmake_marker ();
bzero (&p->phys_cursor, sizeof (p->phys_cursor));
p->desired_matrix = p->current_matrix = 0;
p->phys_cursor_type = -1;
+ p->phys_cursor_width = -1;
p->must_be_updated_p = 0;
XSETFASTINT (p->window_end_vpos, 0);
XSETFASTINT (p->window_end_pos, 0);
XSETWINDOW (val, p);
XSETFASTINT (p->last_point, 0);
p->frozen_window_start_p = 0;
+ p->height_fixed_p = 0;
+ p->last_cursor_off_p = p->cursor_off_p = 0;
Vwindow_list = Qnil;
return val;
}
DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
- "Return the window that the cursor now appears in and commands apply to.")
- ()
+ doc: /* Return the window that the cursor now appears in and commands apply to. */)
+ ()
{
return selected_window;
}
DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
- "Return the window used now for minibuffers.\n\
-If the optional argument FRAME is specified, return the minibuffer window\n\
-used by that frame.")
- (frame)
+ doc: /* Return the window used now for minibuffers.
+If the optional argument FRAME is specified, return the minibuffer window
+used by that frame. */)
+ (frame)
Lisp_Object frame;
{
if (NILP (frame))
frame = selected_frame;
- CHECK_LIVE_FRAME (frame, 0);
+ CHECK_LIVE_FRAME (frame);
return FRAME_MINIBUF_WINDOW (XFRAME (frame));
}
DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1, 0,
- "Returns non-nil if WINDOW is a minibuffer window.")
- (window)
+ doc: /* Returns non-nil if WINDOW is a minibuffer window. */)
+ (window)
Lisp_Object window;
{
struct window *w = decode_window (window);
DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
- Spos_visible_in_window_p, 0, 3, 0,
- "Return t if position POS is currently on the frame in WINDOW.\n\
-Return nil if that position is scrolled vertically out of view.\n\
-If a character is only partially visible, nil is returned, unless the\n\
-optional argument PARTIALLY is non-nil.\n\
-POS defaults to point in WINDOW; WINDOW defaults to the selected window.")
- (pos, window, partially)
+ Spos_visible_in_window_p, 0, 3, 0,
+ doc: /* Return t if position POS is currently on the frame in WINDOW.
+Return nil if that position is scrolled vertically out of view.
+If a character is only partially visible, nil is returned, unless the
+optional argument PARTIALLY is non-nil.
+POS defaults to point in WINDOW; WINDOW defaults to the selected window. */)
+ (pos, window, partially)
Lisp_Object pos, window, partially;
{
register struct window *w;
if (!NILP (pos))
{
- CHECK_NUMBER_COERCE_MARKER (pos, 0);
+ CHECK_NUMBER_COERCE_MARKER (pos);
posint = XINT (pos);
}
else if (w == XWINDOW (selected_window))
if (NILP (window))
return XWINDOW (selected_window);
- CHECK_LIVE_WINDOW (window, 0);
+ CHECK_LIVE_WINDOW (window);
return XWINDOW (window);
}
DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
- "Return the buffer that WINDOW is displaying.")
- (window)
+ doc: /* Return the buffer that WINDOW is displaying. */)
+ (window)
Lisp_Object window;
{
return decode_window (window)->buffer;
}
DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0,
- "Return the number of lines in WINDOW (including its mode line).")
- (window)
+ doc: /* Return the number of lines in WINDOW (including its mode line). */)
+ (window)
Lisp_Object window;
{
return decode_window (window)->height;
}
DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0,
- "Return the number of display columns in WINDOW.\n\
-This is the width that is usable columns available for text in WINDOW.\n\
-If you want to find out how many columns WINDOW takes up,\n\
-use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
- (window)
+ doc: /* Return the number of display columns in WINDOW.
+This is the width that is usable columns available for text in WINDOW.
+If you want to find out how many columns WINDOW takes up,
+use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
+ (window)
Lisp_Object window;
{
return make_number (window_internal_width (decode_window (window)));
}
DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
- "Return the number of columns by which WINDOW is scrolled from left margin.")
- (window)
+ doc: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
+ (window)
Lisp_Object window;
{
return decode_window (window)->hscroll;
}
DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
- "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
-NCOL should be zero or positive.")
- (window, ncol)
- register Lisp_Object window, ncol;
+ doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
+NCOL should be zero or positive.
+
+Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
+window so that the location of point becomes invisible. */)
+ (window, ncol)
+ Lisp_Object window, ncol;
{
- register struct window *w;
+ struct window *w = decode_window (window);
+ int hscroll;
- CHECK_NUMBER (ncol, 1);
- if (XINT (ncol) < 0) XSETFASTINT (ncol, 0);
- w = decode_window (window);
- if (XINT (w->hscroll) != XINT (ncol))
- /* Prevent redisplay shortcuts */
+ CHECK_NUMBER (ncol);
+ hscroll = max (0, XINT (ncol));
+
+ /* Prevent redisplay shortcuts when changing the hscroll. */
+ if (XINT (w->hscroll) != hscroll)
XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
- w->hscroll = ncol;
+
+ w->hscroll = make_number (hscroll);
return ncol;
}
DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
Swindow_redisplay_end_trigger, 0, 1, 0,
- "Return WINDOW's redisplay end trigger value.\n\
-See `set-window-redisplay-end-trigger' for more information.")
- (window)
+ doc: /* Return WINDOW's redisplay end trigger value.
+See `set-window-redisplay-end-trigger' for more information. */)
+ (window)
Lisp_Object window;
{
return decode_window (window)->redisplay_end_trigger;
DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
Sset_window_redisplay_end_trigger, 2, 2, 0,
- "Set WINDOW's redisplay end trigger value to VALUE.\n\
-VALUE should be a buffer position (typically a marker) or nil.\n\
-If it is a buffer position, then if redisplay in WINDOW reaches a position\n\
-beyond VALUE, the functions in `redisplay-end-trigger-functions' are called\n\
-with two arguments: WINDOW, and the end trigger value.\n\
-Afterwards the end-trigger value is reset to nil.")
- (window, value)
+ doc: /* Set WINDOW's redisplay end trigger value to VALUE.
+VALUE should be a buffer position (typically a marker) or nil.
+If it is a buffer position, then if redisplay in WINDOW reaches a position
+beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
+with two arguments: WINDOW, and the end trigger value.
+Afterwards the end-trigger value is reset to nil. */)
+ (window, value)
register Lisp_Object window, value;
{
register struct window *w;
}
DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
- "Return a list of the edge coordinates of WINDOW.\n\
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
-RIGHT is one more than the rightmost column used by WINDOW,\n\
-and BOTTOM is one more than the bottommost row used by WINDOW\n\
- and its mode-line.")
- (window)
+ doc: /* Return a list of the edge coordinates of WINDOW.
+\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
+RIGHT is one more than the rightmost column used by WINDOW,
+and BOTTOM is one more than the bottommost row used by WINDOW
+ and its mode-line. */)
+ (window)
Lisp_Object window;
{
register struct window *w = decode_window (window);
if it is on the border between the window and its right sibling,
return 3.
if it is on the window's top line, return 4;
- if it is in the bitmap area to the left/right of the window,
- return 5 or 6, and convert *X and *Y to window-relative corrdinates.
+ if it is in left or right fringe of the window,
+ return 5 or 6, and convert *X and *Y to window-relative coordinates;
+ if it is in the marginal area to the left/right of the window,
+ return 7 or 8, and convert *X and *Y to window-relative coordinates.
X and Y are frame relative pixel coordinates. */
-static int
+static enum window_part
coordinates_in_window (w, x, y)
register struct window *w;
register int *x, *y;
{
- struct frame *f = XFRAME (WINDOW_FRAME (w));
- int left_x, right_x, top_y, bottom_y;
- int flags_area_width = FRAME_LEFT_FLAGS_AREA_WIDTH (f);
-
/* Let's make this a global enum later, instead of using numbers
everywhere. */
- enum {ON_NOTHING, ON_TEXT, ON_MODE_LINE, ON_VERTICAL_BORDER,
- ON_HEADER_LINE, ON_LEFT_FRINGE, ON_RIGHT_FRINGE};
-
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
+ int left_x, right_x, top_y, bottom_y;
+ enum window_part part;
+ int ux = CANON_X_UNIT (f);
+ int x0 = XFASTINT (w->left) * ux;
+ int x1 = x0 + XFASTINT (w->width) * ux;
+ /* The width of the area where the vertical line can be dragged.
+ (Between mode lines for instance. */
+ int grabbable_width = ux;
+ int lmargin_width = 0, rmargin_width = 0;
+
+ if (*x < x0 || *x >= x1)
+ return ON_NOTHING;
+
/* In what's below, we subtract 1 when computing right_x because we
want the rightmost pixel, which is given by left_pixel+width-1. */
if (w->pseudo_window_p)
{
left_x = 0;
- right_x = XFASTINT (w->width) * CANON_Y_UNIT (f) - 1;
+ right_x = XFASTINT (w->width) * CANON_X_UNIT (f) - 1;
top_y = WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
bottom_y = WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w);
}
sibling, say it's on the vertical line. That's to be able
to resize windows horizontally in case we're using toolkit
scroll bars. */
-
+
if (WINDOW_WANTS_MODELINE_P (w)
- && *y < bottom_y
- && *y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w))
+ && *y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w)
+ && *y < bottom_y)
{
- if (!WINDOW_RIGHTMOST_P (w)
- && (abs (*x - ((XFASTINT (w->left) + XFASTINT (w->width))
- * CANON_X_UNIT (f)))
- < CANON_X_UNIT (f) / 2))
- return ON_VERTICAL_BORDER;
- return ON_MODE_LINE;
+ /* We're somewhere on the mode line. We consider the place
+ between mode lines of horizontally adjacent mode lines
+ as the vertical border. If scroll bars on the left,
+ return the right window. */
+ part = ON_MODE_LINE;
+
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
+ {
+ if (abs (*x - x0) < grabbable_width)
+ part = ON_VERTICAL_BORDER;
+ }
+ else if (!WINDOW_RIGHTMOST_P (w) && abs (*x - x1) < grabbable_width)
+ part = ON_VERTICAL_BORDER;
}
-
- if (WINDOW_WANTS_HEADER_LINE_P (w)
- && *y >= top_y
- && *y < top_y + CURRENT_HEADER_LINE_HEIGHT (w))
+ else if (WINDOW_WANTS_HEADER_LINE_P (w)
+ && *y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
+ && *y >= top_y)
+ {
+ part = ON_HEADER_LINE;
+
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
+ {
+ if (abs (*x - x0) < grabbable_width)
+ part = ON_VERTICAL_BORDER;
+ }
+ else if (!WINDOW_RIGHTMOST_P (w) && abs (*x - x1) < grabbable_width)
+ part = ON_VERTICAL_BORDER;
+ }
+ /* Outside anything interesting? */
+ else if (*y < top_y
+ || *y >= bottom_y
+ || *x < (left_x
+ - FRAME_LEFT_FRINGE_WIDTH (f)
+ - FRAME_LEFT_SCROLL_BAR_WIDTH (f) * ux)
+ || *x > (right_x
+ + FRAME_RIGHT_FRINGE_WIDTH (f)
+ + FRAME_RIGHT_SCROLL_BAR_WIDTH (f) * ux))
{
- if (!WINDOW_RIGHTMOST_P (w)
- && (abs (*x - ((XFASTINT (w->left) + XFASTINT (w->width))
- * CANON_X_UNIT (f)))
- < CANON_X_UNIT (f) / 2))
- return ON_VERTICAL_BORDER;
- return ON_HEADER_LINE;
+ part = ON_NOTHING;
}
-
- /* Completely outside anything interesting? */
- if (*y < top_y
- || *y >= bottom_y
- || *x < (left_x
- - flags_area_width
- - (FRAME_LEFT_SCROLL_BAR_WIDTH (f)
- * CANON_X_UNIT (f)))
- || *x > right_x + flags_area_width)
- return ON_NOTHING;
-
- if (FRAME_WINDOW_P (f))
+ else if (FRAME_WINDOW_P (f))
{
if (!w->pseudo_window_p
&& !FRAME_HAS_VERTICAL_SCROLL_BARS (f)
&& !WINDOW_RIGHTMOST_P (w)
- && (abs (*x - right_x - flags_area_width) < CANON_X_UNIT (f) / 2))
- return ON_VERTICAL_BORDER;
-
- if (*x < left_x || *x > right_x)
+ && (abs (*x - right_x - FRAME_RIGHT_FRINGE_WIDTH (f)) < grabbable_width))
+ {
+ part = ON_VERTICAL_BORDER;
+ }
+ else if (*x < left_x || *x > right_x)
{
- /* Other lines than the mode line don't include flags areas and
+ /* Other lines than the mode line don't include fringes and
scroll bars on the left. */
/* Convert X and Y to window-relative pixel coordinates. */
*x -= left_x;
*y -= top_y;
- return *x < left_x ? ON_LEFT_FRINGE : ON_RIGHT_FRINGE;
+ part = *x < left_x ? ON_LEFT_FRINGE : ON_RIGHT_FRINGE;
+ }
+ else
+ {
+ lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
+ rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
+ /* You can never be on a margin area if its width is zero. */
+ if (lmargin_width
+ && *x <= window_box_right (w, LEFT_MARGIN_AREA))
+ part = ON_LEFT_MARGIN;
+ else if (rmargin_width
+ && *x >= window_box_left (w, RIGHT_MARGIN_AREA))
+ part = ON_RIGHT_MARGIN;
+ else
+ {
+ part = ON_TEXT;
+ *x -= left_x;
+ *y -= top_y;
+ }
}
}
else
terminals, the vertical line's x coordinate is right_x. */
if (*x < left_x || *x > right_x)
{
- /* Other lines than the mode line don't include flags areas and
+ /* Other lines than the mode line don't include fringes and
scroll bars on the left. */
/* Convert X and Y to window-relative pixel coordinates. */
*x -= left_x;
*y -= top_y;
- return *x < left_x ? ON_LEFT_FRINGE : ON_RIGHT_FRINGE;
+ part = *x < left_x ? ON_LEFT_FRINGE : ON_RIGHT_FRINGE;
}
-
/* Here, too, "*x > right_x" is because of character terminals. */
- if (!w->pseudo_window_p
- && !WINDOW_RIGHTMOST_P (w)
- && *x > right_x - CANON_X_UNIT (f))
- /* On the border on the right side of the window? Assume that
- this area begins at RIGHT_X minus a canonical char width. */
- return ON_VERTICAL_BORDER;
+ else if (!w->pseudo_window_p
+ && !WINDOW_RIGHTMOST_P (w)
+ && *x > right_x - ux)
+ {
+ /* On the border on the right side of the window? Assume that
+ this area begins at RIGHT_X minus a canonical char width. */
+ part = ON_VERTICAL_BORDER;
+ }
+ else
+ {
+ lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
+ rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
+ /* You can never be on a margin area if its width is zero.
+ This is especially important for character terminals. */
+ if (lmargin_width
+ && *x <= window_box_right (w, LEFT_MARGIN_AREA))
+ part = ON_LEFT_MARGIN;
+ else if (rmargin_width
+ && *x >= window_box_left (w, RIGHT_MARGIN_AREA))
+ part = ON_RIGHT_MARGIN;
+ else
+ {
+ part = ON_TEXT;
+ /* Convert X and Y to window-relative pixel coordinates. */
+ *x -= left_x;
+ *y -= top_y;
+ }
+ }
}
-
- /* Convert X and Y to window-relative pixel coordinates. */
- *x -= left_x;
- *y -= top_y;
- return ON_TEXT;
+
+ return part;
}
+
DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
- Scoordinates_in_window_p, 2, 2, 0,
- "Return non-nil if COORDINATES are in WINDOW.\n\
-COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
-measured in characters from the upper-left corner of the frame.\n\
-(0 . 0) denotes the character in the upper left corner of the\n\
-frame.\n\
-If COORDINATES are in the text portion of WINDOW,\n\
- the coordinates relative to the window are returned.\n\
-If they are in the mode line of WINDOW, `mode-line' is returned.\n\
-If they are in the top mode line of WINDOW, `header-line' is returned.\n\
-If they are in the bitmap-area to the left of the window,\n\
- `left-bitmap-area' is returned, if they are in the area on the right of\n\
- the window, `right-bitmap-area' is returned.\n\
-If they are on the border between WINDOW and its right sibling,\n\
- `vertical-line' is returned.")
- (coordinates, window)
+ Scoordinates_in_window_p, 2, 2, 0,
+ doc: /* Return non-nil if COORDINATES are in WINDOW.
+COORDINATES is a cons of the form (X . Y), X and Y being distances
+measured in characters from the upper-left corner of the frame.
+\(0 . 0) denotes the character in the upper left corner of the
+frame.
+If COORDINATES are in the text portion of WINDOW,
+ the coordinates relative to the window are returned.
+If they are in the mode line of WINDOW, `mode-line' is returned.
+If they are in the top mode line of WINDOW, `header-line' is returned.
+If they are in the left fringe of WINDOW, `left-fringe' is returned.
+If they are in the right fringe of WINDOW, `right-fringe' is returned.
+If they are on the border between WINDOW and its right sibling,
+ `vertical-line' is returned.
+If they are in the windows's left or right marginal areas, `left-margin'\n\
+ or `right-margin' is returned. */)
+ (coordinates, window)
register Lisp_Object coordinates, window;
{
struct window *w;
int x, y;
Lisp_Object lx, ly;
- CHECK_LIVE_WINDOW (window, 0);
+ CHECK_LIVE_WINDOW (window);
w = XWINDOW (window);
f = XFRAME (w->frame);
- CHECK_CONS (coordinates, 1);
+ CHECK_CONS (coordinates);
lx = Fcar (coordinates);
ly = Fcdr (coordinates);
- CHECK_NUMBER_OR_FLOAT (lx, 1);
- CHECK_NUMBER_OR_FLOAT (ly, 1);
+ CHECK_NUMBER_OR_FLOAT (lx);
+ CHECK_NUMBER_OR_FLOAT (ly);
x = PIXEL_X_FROM_CANON_X (f, lx);
y = PIXEL_Y_FROM_CANON_Y (f, ly);
switch (coordinates_in_window (w, &x, &y))
{
- case 0: /* NOT in window at all. */
+ case ON_NOTHING:
return Qnil;
- case 1: /* In text part of window. */
- /* X and Y are now window relative pixel coordinates.
- Convert them to canonical char units before returning
- them. */
+ case ON_TEXT:
+ /* X and Y are now window relative pixel coordinates. Convert
+ them to canonical char units before returning them. */
return Fcons (CANON_X_FROM_PIXEL_X (f, x),
CANON_Y_FROM_PIXEL_Y (f, y));
- case 2: /* In mode line of window. */
+ case ON_MODE_LINE:
return Qmode_line;
- case 3: /* On right border of window. */
+ case ON_VERTICAL_BORDER:
return Qvertical_line;
- case 4:
+ case ON_HEADER_LINE:
return Qheader_line;
- case 5:
- return Qleft_bitmap_area;
+ case ON_LEFT_FRINGE:
+ return Qleft_fringe;
- case 6:
- return Qright_bitmap_area;
+ case ON_RIGHT_FRINGE:
+ return Qright_fringe;
+
+ case ON_LEFT_MARGIN:
+ return Qleft_margin;
+
+ case ON_RIGHT_MARGIN:
+ return Qright_margin;
default:
abort ();
void *user_data;
{
struct check_window_data *cw = (struct check_window_data *) user_data;
- int found;
+ enum window_part found;
+ int continue_p = 1;
found = coordinates_in_window (w, cw->x, cw->y);
- if (found)
+ if (found != ON_NOTHING)
{
*cw->part = found - 1;
XSETWINDOW (*cw->window, w);
+ continue_p = 0;
}
- return !found;
+ return continue_p;
}
&& tool_bar_p
&& WINDOWP (f->tool_bar_window)
&& XINT (XWINDOW (f->tool_bar_window)->height) > 0
- && coordinates_in_window (XWINDOW (f->tool_bar_window), &x, &y))
+ && (coordinates_in_window (XWINDOW (f->tool_bar_window), &x, &y)
+ != ON_NOTHING))
{
*part = 0;
window = f->tool_bar_window;
}
DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
- "Return window containing coordinates X and Y on FRAME.\n\
-If omitted, FRAME defaults to the currently selected frame.\n\
-The top left corner of the frame is considered to be row 0,\n\
-column 0.")
- (x, y, frame)
- Lisp_Object x, y, frame;
+ doc: /* Return window containing coordinates X and Y on FRAME.
+If omitted, FRAME defaults to the currently selected frame.
+The top left corner of the frame is considered to be row 0,
+column 0. */)
+ (x, y, frame)
+ Lisp_Object x, y, frame;
{
int part;
struct frame *f;
if (NILP (frame))
frame = selected_frame;
- CHECK_LIVE_FRAME (frame, 2);
+ CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
/* Check that arguments are integers or floats. */
- CHECK_NUMBER_OR_FLOAT (x, 0);
- CHECK_NUMBER_OR_FLOAT (y, 1);
+ CHECK_NUMBER_OR_FLOAT (x);
+ CHECK_NUMBER_OR_FLOAT (y);
return window_from_coordinates (f,
PIXEL_X_FROM_CANON_X (f, x),
}
DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
- "Return current value of point in WINDOW.\n\
-For a nonselected window, this is the value point would have\n\
-if that window were selected.\n\
-\n\
-Note that, when WINDOW is the selected window and its buffer\n\
-is also currently selected, the value returned is the same as (point).\n\
-It would be more strictly correct to return the `top-level' value\n\
-of point, outside of any save-excursion forms.\n\
-But that is hard to define.")
- (window)
+ doc: /* Return current value of point in WINDOW.
+For a nonselected window, this is the value point would have
+if that window were selected.
+
+Note that, when WINDOW is the selected window and its buffer
+is also currently selected, the value returned is the same as (point).
+It would be more strictly correct to return the `top-level' value
+of point, outside of any save-excursion forms.
+But that is hard to define. */)
+ (window)
Lisp_Object window;
{
register struct window *w = decode_window (window);
}
DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
- "Return position at which display currently starts in WINDOW.\n\
-This is updated by redisplay or by calling `set-window-start'.")
- (window)
+ doc: /* Return position at which display currently starts in WINDOW.
+This is updated by redisplay or by calling `set-window-start'. */)
+ (window)
Lisp_Object window;
{
return Fmarker_position (decode_window (window)->start);
/* This is text temporarily removed from the doc string below.
-This function returns nil if the position is not currently known.\n\
-That happens when redisplay is preempted and doesn't finish.\n\
-If in that case you want to compute where the end of the window would\n\
-have been if redisplay had finished, do this:\n\
- (save-excursion\n\
- (goto-char (window-start window))\n\
- (vertical-motion (1- (window-height window)) window)\n\
+This function returns nil if the position is not currently known.
+That happens when redisplay is preempted and doesn't finish.
+If in that case you want to compute where the end of the window would
+have been if redisplay had finished, do this:
+ (save-excursion
+ (goto-char (window-start window))
+ (vertical-motion (1- (window-height window)) window)
(point))") */
DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0,
- "Return position at which display currently ends in WINDOW.\n\
-This is updated by redisplay, when it runs to completion.\n\
-Simply changing the buffer text or setting `window-start'\n\
-does not update this value.\n\
-If UP-TO-DATE is non-nil, compute the up-to-date position\n\
-if it isn't already recorded.")
- (window, update)
+ doc: /* Return position at which display currently ends in WINDOW.
+This is updated by redisplay, when it runs to completion.
+Simply changing the buffer text or setting `window-start'
+does not update this value.
+If UPDATE is non-nil, compute the up-to-date position
+if it isn't already recorded. */)
+ (window, update)
Lisp_Object window, update;
{
Lisp_Object value;
Lisp_Object buf;
buf = w->buffer;
- CHECK_BUFFER (buf, 0);
+ CHECK_BUFFER (buf);
#if 0 /* This change broke some things. We should make it later. */
/* If we don't know the end position, return nil.
{
struct text_pos startp;
struct it it;
+ struct buffer *old_buffer = NULL, *b = XBUFFER (buf);
/* In case W->start is out of the range, use something
- reasonable. This situation occured when loading a file with
+ reasonable. This situation occurred when loading a file with
`-l' containing a call to `rmail' with subsequent other
commands. At the end, W->start happened to be BEG, while
rmail had already narrowed the buffer. */
/* Cannot use Fvertical_motion because that function doesn't
cope with variable-height lines. */
+ if (b != current_buffer)
+ {
+ old_buffer = current_buffer;
+ set_buffer_internal (b);
+ }
+
start_display (&it, w, startp);
move_it_vertically (&it, window_box_height (w));
+ if (it.current_y < it.last_visible_y)
+ move_it_past_eol (&it);
value = make_number (IT_CHARPOS (it));
+
+ if (old_buffer)
+ set_buffer_internal (old_buffer);
}
else
XSETINT (value, BUF_Z (XBUFFER (buf)) - XFASTINT (w->window_end_pos));
}
DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
- "Make point value in WINDOW be at position POS in WINDOW's buffer.")
- (window, pos)
+ doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer. */)
+ (window, pos)
Lisp_Object window, pos;
{
register struct window *w = decode_window (window);
- CHECK_NUMBER_COERCE_MARKER (pos, 1);
+ CHECK_NUMBER_COERCE_MARKER (pos);
if (w == XWINDOW (selected_window)
&& XBUFFER (w->buffer) == current_buffer)
Fgoto_char (pos);
else
set_marker_restricted (w->pointm, pos, w->buffer);
+
+ /* We have to make sure that redisplay updates the window to show
+ the new value of point. */
+ if (!EQ (window, selected_window))
+ ++windows_or_buffers_changed;
return pos;
}
DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
- "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
-Optional third arg NOFORCE non-nil inhibits next redisplay\n\
-from overriding motion of point in order to display at this exact start.")
- (window, pos, noforce)
+ doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
+Optional third arg NOFORCE non-nil inhibits next redisplay
+from overriding motion of point in order to display at this exact start. */)
+ (window, pos, noforce)
Lisp_Object window, pos, noforce;
{
register struct window *w = decode_window (window);
- CHECK_NUMBER_COERCE_MARKER (pos, 1);
+ CHECK_NUMBER_COERCE_MARKER (pos);
set_marker_restricted (w->start, pos, w->buffer);
/* this is not right, but much easier than doing what is right. */
w->start_at_line_beg = Qnil;
DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
1, 1, 0,
- "Return WINDOW's dedicated object, usually t or nil.\n\
-See also `set-window-dedicated-p'.")
- (window)
+ doc: /* Return WINDOW's dedicated object, usually t or nil.
+See also `set-window-dedicated-p'. */)
+ (window)
Lisp_Object window;
{
return decode_window (window)->dedicated;
DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
Sset_window_dedicated_p, 2, 2, 0,
- "Control whether WINDOW is dedicated to the buffer it displays.\n\
-If it is dedicated, Emacs will not automatically change\n\
-which buffer appears in it.\n\
-The second argument is the new value for the dedication flag;\n\
-non-nil means yes.")
- (window, arg)
- Lisp_Object window, arg;
+ doc: /* Control whether WINDOW is dedicated to the buffer it displays.
+If it is dedicated, Emacs will not automatically change
+which buffer appears in it.
+The second argument is the new value for the dedication flag;
+non-nil means yes. */)
+ (window, arg)
+ Lisp_Object window, arg;
{
register struct window *w = decode_window (window);
DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
0, 1, 0,
- "Return the display-table that WINDOW is using.")
- (window)
+ doc: /* Return the display-table that WINDOW is using. */)
+ (window)
Lisp_Object window;
{
return decode_window (window)->display_table;
}
DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
- "Set WINDOW's display-table to TABLE.")
- (window, table)
+ doc: /* Set WINDOW's display-table to TABLE. */)
+ (window, table)
register Lisp_Object window, table;
{
register struct window *w;
bzero (&p->last_cursor, sizeof (p->last_cursor));
bzero (&p->phys_cursor, sizeof (p->phys_cursor));
p->phys_cursor_type = -1;
+ p->phys_cursor_width = -1;
p->must_be_updated_p = 0;
p->pseudo_window_p = 0;
XSETFASTINT (p->window_end_vpos, 0);
}
DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "",
- "Remove WINDOW from the display. Default is selected window.")
- (window)
+ doc: /* Remove WINDOW from the display. Default is selected window. */)
+ (window)
register Lisp_Object window;
{
delete_window (window);
register Lisp_Object tem, parent, sib;
register struct window *p;
register struct window *par;
- FRAME_PTR frame;
+ struct frame *f;
/* Because this function is called by other C code on non-leaf
windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
if (NILP (window))
window = selected_window;
else
- CHECK_WINDOW (window, 0);
+ CHECK_WINDOW (window);
p = XWINDOW (window);
/* It's okay to delete an already-deleted window. */
windows_or_buffers_changed++;
Vwindow_list = Qnil;
- frame = XFRAME (WINDOW_FRAME (p));
- FRAME_WINDOW_SIZES_CHANGED (frame) = 1;
+ f = XFRAME (WINDOW_FRAME (p));
+ FRAME_WINDOW_SIZES_CHANGED (f) = 1;
/* Are we trying to delete any frame's selected window? */
{
- Lisp_Object frame, pwindow;
+ Lisp_Object swindow, pwindow;
/* See if the frame's selected window is either WINDOW
or any subwindow of it, by finding all that window's parents
and comparing each one with WINDOW. */
- frame = WINDOW_FRAME (XWINDOW (window));
- pwindow = FRAME_SELECTED_WINDOW (XFRAME (frame));
+ swindow = FRAME_SELECTED_WINDOW (f);
- while (!NILP (pwindow))
+ while (1)
{
- if (EQ (window, pwindow))
+ pwindow = swindow;
+ while (!NILP (pwindow))
+ {
+ if (EQ (window, pwindow))
+ break;
+ pwindow = XWINDOW (pwindow)->parent;
+ }
+
+ /* If the window being deleted is not a parent of SWINDOW,
+ then SWINDOW is ok as the new selected window. */
+ if (!EQ (window, pwindow))
break;
- pwindow = XWINDOW (pwindow)->parent;
+ /* Otherwise, try another window for SWINDOW. */
+ swindow = Fnext_window (swindow, Qlambda, Qnil);;
+
+ /* If we get back to the frame's selected window,
+ it means there was no acceptable alternative,
+ so we cannot delete. */
+ if (EQ (swindow, FRAME_SELECTED_WINDOW (f)))
+ error ("Cannot delete window");
}
- if (EQ (window, pwindow))
+ /* If we need to change SWINDOW, do it. */
+ if (! EQ (swindow, FRAME_SELECTED_WINDOW (f)))
{
- Lisp_Object alternative;
- alternative = Fnext_window (window, Qlambda, Qnil);
-
/* If we're about to delete the selected window on the
selected frame, then we should use Fselect_window to select
the new window. On the other hand, if we're about to
delete the selected window on any other frame, we shouldn't do
anything but set the frame's selected_window slot. */
- if (EQ (window, selected_window))
- Fselect_window (alternative);
+ if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
+ Fselect_window (swindow);
else
- FRAME_SELECTED_WINDOW (XFRAME (frame)) = alternative;
+ FRAME_SELECTED_WINDOW (f) = swindow;
}
}
events and other events that access glyph matrices are not
processed while we are changing them. */
BLOCK_INPUT;
- free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (frame)));
+ free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)));
tem = p->next;
if (!NILP (tem))
p->buffer = p->hchild = p->vchild = Qnil;
/* Adjust glyph matrices. */
- adjust_glyphs (frame);
+ adjust_glyphs (f);
UNBLOCK_INPUT;
}
if (NILP (*window))
*window = selected_window;
else
- CHECK_LIVE_WINDOW (*window, 0);
+ CHECK_LIVE_WINDOW (*window);
/* MINIBUF nil may or may not include minibuffers. Decide if it
does. */
}
-/* This comment supplies the doc string for `next-window',
- for make-docfile to see. We cannot put this in the real DEFUN
- due to limits in the Unix cpp.
-
-DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
- "Return next window after WINDOW in canonical ordering of windows.\n\
-If omitted, WINDOW defaults to the selected window.\n\
-\n\
-Optional second arg MINIBUF t means count the minibuffer window even\n\
-if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
-it is active. MINIBUF neither t nor nil means not to count the\n\
-minibuffer even if it is active.\n\
-\n\
-Several frames may share a single minibuffer; if the minibuffer\n\
-counts, all windows on all frames that share that minibuffer count\n\
-too. Therefore, `next-window' can be used to iterate through the\n\
-set of windows even when the minibuffer is on another frame. If the\n\
-minibuffer does not count, only windows from WINDOW's frame count.\n\
-\n\
-Optional third arg ALL-FRAMES t means include windows on all frames.\n\
-ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
-above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
-ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
-If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
-Anything else means restrict to WINDOW's frame.\n\
-\n\
-If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
-`next-window' to iterate through the entire cycle of acceptable\n\
-windows, eventually ending up back at the window you started with.\n\
-`previous-window' traverses the same cycle, in the reverse order.")
- (window, minibuf, all_frames) */
-
DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
- 0)
- (window, minibuf, all_frames)
+ doc: /* Return next window after WINDOW in canonical ordering of windows.
+If omitted, WINDOW defaults to the selected window.
+
+Optional second arg MINIBUF t means count the minibuffer window even
+if not active. MINIBUF nil or omitted means count the minibuffer iff
+it is active. MINIBUF neither t nor nil means not to count the
+minibuffer even if it is active.
+
+Several frames may share a single minibuffer; if the minibuffer
+counts, all windows on all frames that share that minibuffer count
+too. Therefore, `next-window' can be used to iterate through the
+set of windows even when the minibuffer is on another frame. If the
+minibuffer does not count, only windows from WINDOW's frame count.
+
+Optional third arg ALL-FRAMES t means include windows on all frames.
+ALL-FRAMES nil or omitted means cycle within the frames as specified
+above. ALL-FRAMES = `visible' means include windows on all visible frames.
+ALL-FRAMES = 0 means include windows on all visible and iconified frames.
+If ALL-FRAMES is a frame, restrict search to windows on that frame.
+Anything else means restrict to WINDOW's frame.
+
+If you use consistent values for MINIBUF and ALL-FRAMES, you can use
+`next-window' to iterate through the entire cycle of acceptable
+windows, eventually ending up back at the window you started with.
+`previous-window' traverses the same cycle, in the reverse order. */)
+ (window, minibuf, all_frames)
Lisp_Object window, minibuf, all_frames;
{
return next_window (window, minibuf, all_frames, 1);
}
-/* This comment supplies the doc string for `previous-window',
- for make-docfile to see. We cannot put this in the real DEFUN
- due to limits in the Unix cpp.
-
-DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
- "Return the window preceding WINDOW in canonical ordering of windows.\n\
-If omitted, WINDOW defaults to the selected window.\n\
-\n\
-Optional second arg MINIBUF t means count the minibuffer window even\n\
-if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
-it is active. MINIBUF neither t nor nil means not to count the\n\
-minibuffer even if it is active.\n\
-\n\
-Several frames may share a single minibuffer; if the minibuffer\n\
-counts, all windows on all frames that share that minibuffer count\n\
-too. Therefore, `previous-window' can be used to iterate through\n\
-the set of windows even when the minibuffer is on another frame. If\n\
-the minibuffer does not count, only windows from WINDOW's frame count\n\
-\n\
-Optional third arg ALL-FRAMES t means include windows on all frames.\n\
-ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
-above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
-ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
-If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
-Anything else means restrict to WINDOW's frame.\n\
-\n\
-If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
-`previous-window' to iterate through the entire cycle of acceptable\n\
-windows, eventually ending up back at the window you started with.\n\
-`next-window' traverses the same cycle, in the reverse order.")
- (window, minibuf, all_frames) */
-
-
DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0,
- 0)
- (window, minibuf, all_frames)
+ doc: /* Return the window preceding WINDOW in canonical ordering of windows.
+If omitted, WINDOW defaults to the selected window.
+
+Optional second arg MINIBUF t means count the minibuffer window even
+if not active. MINIBUF nil or omitted means count the minibuffer iff
+it is active. MINIBUF neither t nor nil means not to count the
+minibuffer even if it is active.
+
+Several frames may share a single minibuffer; if the minibuffer
+counts, all windows on all frames that share that minibuffer count
+too. Therefore, `previous-window' can be used to iterate through
+the set of windows even when the minibuffer is on another frame. If
+the minibuffer does not count, only windows from WINDOW's frame count
+
+Optional third arg ALL-FRAMES t means include windows on all frames.
+ALL-FRAMES nil or omitted means cycle within the frames as specified
+above. ALL-FRAMES = `visible' means include windows on all visible frames.
+ALL-FRAMES = 0 means include windows on all visible and iconified frames.
+If ALL-FRAMES is a frame, restrict search to windows on that frame.
+Anything else means restrict to WINDOW's frame.
+
+If you use consistent values for MINIBUF and ALL-FRAMES, you can use
+`previous-window' to iterate through the entire cycle of acceptable
+windows, eventually ending up back at the window you started with.
+`next-window' traverses the same cycle, in the reverse order. */)
+ (window, minibuf, all_frames)
Lisp_Object window, minibuf, all_frames;
{
return next_window (window, minibuf, all_frames, 0);
DEFUN ("other-window", Fother_window, Sother_window, 1, 2, "p",
- "Select the ARG'th different window on this frame.\n\
-All windows on current frame are arranged in a cyclic order.\n\
-This command selects the window ARG steps away in that order.\n\
-A negative ARG moves in the opposite order. If the optional second\n\
-argument ALL_FRAMES is non-nil, cycle through all frames.")
- (arg, all_frames)
+ doc: /* Select the ARG'th different window on this frame.
+All windows on current frame are arranged in a cyclic order.
+This command selects the window ARG steps away in that order.
+A negative ARG moves in the opposite order. If the optional second
+argument ALL_FRAMES is non-nil, cycle through all frames. */)
+ (arg, all_frames)
Lisp_Object arg, all_frames;
{
Lisp_Object window;
int i;
- CHECK_NUMBER (arg, 0);
+ CHECK_NUMBER (arg);
window = selected_window;
for (i = XINT (arg); i > 0; --i)
window = Fnext_window (window, Qnil, all_frames);
for (; i < 0; ++i)
window = Fprevious_window (window, Qnil, all_frames);
-
+
Fselect_window (window);
return Qnil;
}
DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0,
- "Return a list of windows on FRAME, starting with WINDOW.\n\
-FRAME nil or omitted means use the selected frame.\n\
-WINDOW nil or omitted means use the selected window.\n\
-MINIBUF t means include the minibuffer window, even if it isn't active.\n\
-MINIBUF nil or omitted means include the minibuffer window only\n\
-if it's active.\n\
-MINIBUF neither nil nor t means never include the minibuffer window.")
- (frame, minibuf, window)
+ doc: /* Return a list of windows on FRAME, starting with WINDOW.
+FRAME nil or omitted means use the selected frame.
+WINDOW nil or omitted means use the selected window.
+MINIBUF t means include the minibuffer window, even if it isn't active.
+MINIBUF nil or omitted means include the minibuffer window only
+if it's active.
+MINIBUF neither nil nor t means never include the minibuffer window. */)
+ (frame, minibuf, window)
Lisp_Object frame, minibuf, window;
{
- Lisp_Object list;
-
if (NILP (window))
window = selected_window;
if (NILP (frame))
Qnil, look at just the selected frame;
Qvisible, look at visible frames;
a frame, just look at windows on that frame.
- If MINI is non-zero, perform the operation on minibuffer windows too.
-*/
+ If MINI is non-zero, perform the operation on minibuffer windows too. */
enum window_loop
{
else
window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
- /* Figure out the last window we're going to mess with. Since
- Fnext_window, given the same options, is guaranteed to go in a
- ring, we can just use Fprevious_window to find the last one.
-
- We can't just wait until we hit the first window again, because
- it might be deleted. */
-
windows = window_list_1 (window, mini ? Qt : Qnil, frame_arg);
GCPRO1 (windows);
best_window = Qnil;
? EQ (window, minibuf_window)
: 1))
{
- UNGCPRO;
- return window;
+ if (NILP (best_window))
+ best_window = window;
+ else if (EQ (window, selected_window))
+ /* For compatibility with 20.x, prefer to return
+ selected-window. */
+ best_window = window;
}
break;
display there. */
Lisp_Object buffer;
buffer = Fother_buffer (obj, Qnil, w->frame);
- if (NILP (buffer))
- buffer = Fget_buffer_create (build_string ("*scratch*"));
Fset_window_buffer (window, buffer);
if (EQ (window, selected_window))
Fset_buffer (w->buffer);
/* Find another buffer to show in this window. */
buffer = Fother_buffer (obj, Qnil, w->frame);
- if (NILP (buffer))
- buffer = Fget_buffer_create (build_string ("*scratch*"));
/* If this window is dedicated, and in a frame of its own,
kill the frame. */
}
DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0,
- "Return the window least recently selected or used for display.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is nil, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
- (frame)
- Lisp_Object frame;
+ doc: /* Return the window least recently selected or used for display.
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is nil, search only the selected frame.
+If FRAME is a frame, search only that frame. */)
+ (frame)
+ Lisp_Object frame;
{
register Lisp_Object w;
/* First try for a window that is full-width */
}
DEFUN ("get-largest-window", Fget_largest_window, Sget_largest_window, 0, 1, 0,
- "Return the largest window in area.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is nil, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
- (frame)
- Lisp_Object frame;
+ doc: /* Return the largest window in area.
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is nil, search only the selected frame.
+If FRAME is a frame, search only that frame. */)
+ (frame)
+ Lisp_Object frame;
{
return window_loop (GET_LARGEST_WINDOW, Qnil, 0,
frame);
}
DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 1, 2, 0,
- "Return a window currently displaying BUFFER, or nil if none.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If optional argument FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is nil, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
- (buffer, frame)
- Lisp_Object buffer, frame;
+ doc: /* Return a window currently displaying BUFFER, or nil if none.
+If optional argument FRAME is `visible', search all visible frames.
+If optional argument FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is nil, search only the selected frame.
+If FRAME is a frame, search only that frame. */)
+ (buffer, frame)
+ Lisp_Object buffer, frame;
{
buffer = Fget_buffer (buffer);
if (BUFFERP (buffer))
}
DEFUN ("delete-other-windows", Fdelete_other_windows, Sdelete_other_windows,
- 0, 1, "",
- "Make WINDOW (or the selected window) fill its frame.\n\
-Only the frame WINDOW is on is affected.\n\
-This function tries to reduce display jumps\n\
-by keeping the text previously visible in WINDOW\n\
-in the same place on the frame. Doing this depends on\n\
-the value of (window-start WINDOW), so if calling this function\n\
-in a program gives strange scrolling, make sure the window-start\n\
-value is reasonable when this function is called.")
- (window)
+ 0, 1, "",
+ doc: /* Make WINDOW (or the selected window) fill its frame.
+Only the frame WINDOW is on is affected.
+This function tries to reduce display jumps
+by keeping the text previously visible in WINDOW
+in the same place on the frame. Doing this depends on
+the value of (window-start WINDOW), so if calling this function
+in a program gives strange scrolling, make sure the window-start
+value is reasonable when this function is called. */)
+ (window)
Lisp_Object window;
{
struct window *w;
int startpos;
- int top;
+ int top, new_top;
if (NILP (window))
window = selected_window;
else
- CHECK_LIVE_WINDOW (window, 0);
-
+ CHECK_LIVE_WINDOW (window);
w = XWINDOW (window);
startpos = marker_position (w->start);
on the frame. But don't try to do this if the window start is
outside the visible portion (as might happen when the display is
not current, due to typeahead). */
- if (startpos >= BUF_BEGV (XBUFFER (w->buffer))
+ new_top = XFASTINT (w->top) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
+ if (new_top != top
+ && startpos >= BUF_BEGV (XBUFFER (w->buffer))
&& startpos <= BUF_ZV (XBUFFER (w->buffer)))
{
struct position pos;
pos = *vmotion (startpos, -top, w);
set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
+ w->window_end_valid = Qnil;
w->start_at_line_beg = ((pos.bytepos == BEGV_BYTE
|| FETCH_BYTE (pos.bytepos - 1) == '\n') ? Qt
: Qnil);
}
DEFUN ("delete-windows-on", Fdelete_windows_on, Sdelete_windows_on,
- 1, 2, "bDelete windows on (buffer): ",
- "Delete all windows showing BUFFER.\n\
-Optional second argument FRAME controls which frames are affected.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is nil, search all frames.\n\
-If FRAME is t, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
- (buffer, frame)
+ 1, 2, "bDelete windows on (buffer): ",
+ doc: /* Delete all windows showing BUFFER.
+Optional second argument FRAME controls which frames are affected.
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is nil, search all frames.
+If FRAME is t, search only the selected frame.
+If FRAME is a frame, search only that frame. */)
+ (buffer, frame)
Lisp_Object buffer, frame;
{
/* FRAME uses t and nil to mean the opposite of what window_loop
if (!NILP (buffer))
{
buffer = Fget_buffer (buffer);
- CHECK_BUFFER (buffer, 0);
+ CHECK_BUFFER (buffer);
window_loop (DELETE_BUFFER_WINDOWS, buffer, 0, frame);
}
}
DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows,
- Sreplace_buffer_in_windows,
- 1, 1, "bReplace buffer in windows: ",
- "Replace BUFFER with some other buffer in all windows showing it.")
- (buffer)
+ Sreplace_buffer_in_windows,
+ 1, 1, "bReplace buffer in windows: ",
+ doc: /* Replace BUFFER with some other buffer in all windows showing it. */)
+ (buffer)
Lisp_Object buffer;
{
if (!NILP (buffer))
{
buffer = Fget_buffer (buffer);
- CHECK_BUFFER (buffer, 0);
+ CHECK_BUFFER (buffer);
window_loop (UNSHOW_BUFFER, buffer, 0, Qt);
}
return Qnil;
might crash Emacs. */
#define MIN_SAFE_WINDOW_WIDTH (2)
-#define MIN_SAFE_WINDOW_HEIGHT (2)
+#define MIN_SAFE_WINDOW_HEIGHT (1)
/* Make sure that window_min_height and window_min_width are
not too small; if they are, set them to safe minima. */
int *rows, *cols;
{
/* For height, we have to see:
- whether the frame has a minibuffer,
- whether it wants a mode line, and
- whether it has a menu bar. */
- int min_height =
- (FRAME_MINIBUF_ONLY_P (frame) ? MIN_SAFE_WINDOW_HEIGHT - 1
- : (! FRAME_HAS_MINIBUF_P (frame)) ? MIN_SAFE_WINDOW_HEIGHT
- : 2 * MIN_SAFE_WINDOW_HEIGHT - 1);
+ how many windows the frame has at minimum (one or two),
+ and whether it has a menu bar or other special stuff at the top. */
+ int min_height
+ = ((FRAME_MINIBUF_ONLY_P (frame) || ! FRAME_HAS_MINIBUF_P (frame))
+ ? MIN_SAFE_WINDOW_HEIGHT
+ : 2 * MIN_SAFE_WINDOW_HEIGHT);
if (FRAME_TOP_MARGIN (frame) > 0)
min_height += FRAME_TOP_MARGIN (frame);
WINDOW's width. Resize WINDOW's children, if any, so that they
keep their proportionate size relative to WINDOW. Propagate
WINDOW's top or left edge position to children. Delete windows
- that become too small unless NODELETE_P is non-zero. */
+ that become too small unless NODELETE_P is non-zero.
+
+ If NODELETE_P is 2, that means we do delete windows that are
+ too small, even if they were too small before! */
static void
size_window (window, size, width_p, nodelete_p)
Lisp_Object child, *forward, *sideward;
int old_size, min_size;
+ if (nodelete_p == 2)
+ nodelete_p = 0;
+
check_min_window_sizes ();
size = max (0, size);
old_size = XINT (w->height);
min_size = window_min_height;
}
-
- if (old_size < window_min_width)
+
+ if (old_size < min_size && nodelete_p != 2)
w->too_small_ok = Qt;
/* Maybe delete WINDOW if it's too small. */
- if (!nodelete_p && !NILP (w->parent))
+ if (nodelete_p != 1 && !NILP (w->parent))
{
- int min_size;
-
if (!MINI_WINDOW_P (w) && !NILP (w->too_small_ok))
min_size = width_p ? MIN_SAFE_WINDOW_WIDTH : MIN_SAFE_WINDOW_HEIGHT;
else
sideward = &w->hchild;
forward = &w->vchild;
w->height = make_number (size);
+ w->orig_height = Qnil;
}
if (!NILP (*sideward))
int child_size;
c = XWINDOW (child);
child_size = width_p ? XINT (c->width) : XINT (c->height);
- size_window (child, child_size, width_p, 0);
+ size_window (child, child_size, width_p, 2);
}
}
}
{
struct window *w = XWINDOW (window);
struct buffer *b = XBUFFER (buffer);
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
w->buffer = buffer;
XSETFASTINT (w->window_end_vpos, 0);
bzero (&w->last_cursor, sizeof w->last_cursor);
w->window_end_valid = Qnil;
- XSETFASTINT (w->hscroll, 0);
+ w->hscroll = w->min_hscroll = make_number (0);
+ w->vscroll = 0;
set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
set_marker_restricted (w->start,
make_number (b->last_window_start),
DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 2, 0,
- "Make WINDOW display BUFFER as its contents.\n\
-BUFFER can be a buffer or buffer name.")
- (window, buffer)
+ doc: /* Make WINDOW display BUFFER as its contents.
+BUFFER can be a buffer or buffer name. */)
+ (window, buffer)
register Lisp_Object window, buffer;
{
register Lisp_Object tem;
XSETWINDOW (window, w);
buffer = Fget_buffer (buffer);
- CHECK_BUFFER (buffer, 1);
+ CHECK_BUFFER (buffer);
if (NILP (XBUFFER (buffer)->name))
error ("Attempt to display deleted buffer");
{
if (!NILP (w->dedicated) && !EQ (tem, buffer))
error ("Window is dedicated to `%s'",
- XSTRING (XBUFFER (tem)->name)->data);
+ SDATA (XBUFFER (tem)->name));
unshow_buffer (w);
}
}
DEFUN ("select-window", Fselect_window, Sselect_window, 1, 1, 0,
- "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
-If WINDOW is not already selected, also make WINDOW's buffer current.\n\
-Note that the main editor command loop\n\
-selects the buffer of the selected window before each command.")
- (window)
+ doc: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
+If WINDOW is not already selected, also make WINDOW's buffer current.
+If WINDOW's frame is the selected frame, also make WINDOW the frame's
+selected window.
+
+Note that the main editor command loop
+selects the buffer of the selected window before each command. */)
+ (window)
register Lisp_Object window;
{
return select_window_1 (window, 1);
register struct window *ow;
struct frame *sf;
- CHECK_LIVE_WINDOW (window, 0);
+ CHECK_LIVE_WINDOW (window);
w = XWINDOW (window);
-
- if (NILP (w->buffer))
- error ("Trying to select deleted window or non-leaf window");
+ w->frozen_window_start_p = 0;
XSETFASTINT (w->use_time, ++window_select_count);
if (EQ (window, selected_window))
selected_window = window;
sf = SELECTED_FRAME ();
- if (XFRAME (WINDOW_FRAME (w)) != sf)
- {
- XFRAME (WINDOW_FRAME (w))->selected_window = window;
- /* Use this rather than Fhandle_switch_frame
- 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);
- }
- else
+ if (XFRAME (WINDOW_FRAME (w)) == sf)
sf->selected_window = window;
if (recordflag)
}
DEFUN ("special-display-p", Fspecial_display_p, Sspecial_display_p, 1, 1, 0,
- "Returns non-nil if a buffer named BUFFER-NAME would be created specially.\n\
-The value is actually t if the frame should be called with default frame\n\
-parameters, and a list of frame parameters if they were specified.\n\
-See `special-display-buffer-names', and `special-display-regexps'.")
- (buffer_name)
+ doc: /* Returns non-nil if a buffer named BUFFER-NAME would be created specially.
+The value is actually t if the frame should be called with default frame
+parameters, and a list of frame parameters if they were specified.
+See `special-display-buffer-names', and `special-display-regexps'. */)
+ (buffer_name)
Lisp_Object buffer_name;
{
Lisp_Object tem;
- CHECK_STRING (buffer_name, 1);
+ CHECK_STRING (buffer_name);
tem = Fmember (buffer_name, Vspecial_display_buffer_names);
if (!NILP (tem))
}
DEFUN ("same-window-p", Fsame_window_p, Ssame_window_p, 1, 1, 0,
- "Returns non-nil if a new buffer named BUFFER-NAME would use the same window.\n\
-See `same-window-buffer-names' and `same-window-regexps'.")
- (buffer_name)
+ doc: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
+See `same-window-buffer-names' and `same-window-regexps'. */)
+ (buffer_name)
Lisp_Object buffer_name;
{
Lisp_Object tem;
- CHECK_STRING (buffer_name, 1);
+ CHECK_STRING (buffer_name);
tem = Fmember (buffer_name, Vsame_window_buffer_names);
if (!NILP (tem))
return Qnil;
}
- /* Use B so the default is (other-buffer). */
+/* Use B so the default is (other-buffer). */
DEFUN ("display-buffer", Fdisplay_buffer, Sdisplay_buffer, 1, 3,
- "BDisplay buffer: \nP",
- "Make BUFFER appear in some window but don't select it.\n\
-BUFFER can be a buffer or a buffer name.\n\
-If BUFFER is shown already in some window, just use that one,\n\
-unless the window is the selected window and the optional second\n\
-argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
-If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
-Returns the window displaying BUFFER.\n\
-If `display-reuse-frames' is non-nil, and another frame is currently\n\
-displaying BUFFER, then simply raise that frame.\n\
-\n\
-The variables `special-display-buffer-names', `special-display-regexps',\n\
-`same-window-buffer-names', and `same-window-regexps' customize how certain\n\
-buffer names are handled.\n\
-\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is a frame, search only that frame.\n\
-If FRAME is nil, search only the selected frame\n\
- (actually the last nonminibuffer frame),\n\
- unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,\n\
- which means search visible and iconified frames.\n\
-\n\
-If `even-window-heights' is non-nil, window heights will be evened out\n\
-if displaying the buffer causes two vertically\ adjacent windows to be\n\
-displayed.")
- (buffer, not_this_window, frame)
+ "BDisplay buffer: \nP",
+ doc: /* Make BUFFER appear in some window but don't select it.
+BUFFER can be a buffer or a buffer name.
+If BUFFER is shown already in some window, just use that one,
+unless the window is the selected window and the optional second
+argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
+If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
+Returns the window displaying BUFFER.
+If `display-buffer-reuse-frames' is non-nil, and another frame is currently
+displaying BUFFER, then simply raise that frame.
+
+The variables `special-display-buffer-names', `special-display-regexps',
+`same-window-buffer-names', and `same-window-regexps' customize how certain
+buffer names are handled.
+
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is a frame, search only that frame.
+If FRAME is nil, search only the selected frame
+ (actually the last nonminibuffer frame),
+ unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
+ which means search visible and iconified frames.
+
+If `even-window-heights' is non-nil, window heights will be evened out
+if displaying the buffer causes two vertically adjacent windows to be
+displayed. */)
+ (buffer, not_this_window, frame)
register Lisp_Object buffer, not_this_window, frame;
{
register Lisp_Object window, tem, swp;
swp = Qnil;
buffer = Fget_buffer (buffer);
- CHECK_BUFFER (buffer, 0);
+ CHECK_BUFFER (buffer);
if (!NILP (Vdisplay_buffer_function))
return call2 (Vdisplay_buffer_function, buffer, not_this_window);
}
}
- /* If the user wants pop-up-frames or display-reuse-frames, then
+ /* If the user wants pop-up-frames or display-buffer-reuse-frames,
look for a window showing BUFFER on any visible or iconified frame.
Otherwise search only the current frame. */
if (! NILP (frame))
+ XFASTINT (XWINDOW (window)->height));
enlarge_window (upper,
total / 2 - XFASTINT (XWINDOW (upper)->height),
- 0);
+ 0, 0);
}
}
}
BEGV = BEG;
ZV = Z;
SET_PT (BEG);
+#if 0 /* rms: there should be no reason for this. */
XBUFFER (buf)->prevent_redisplay_optimizations_p = 1;
+#endif
set_buffer_internal (old);
if (!EQ (Vtemp_buffer_show_function, Qnil))
Vminibuf_scroll_window = window;
w = XWINDOW (window);
XSETFASTINT (w->hscroll, 0);
+ XSETFASTINT (w->min_hscroll, 0);
set_marker_restricted_both (w->start, buf, 1, 1);
set_marker_restricted_both (w->pointm, buf, 1, 1);
tem = Fsymbol_value (Qtemp_buffer_show_hook);
if (!NILP (tem))
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object prev_window;
prev_window = selected_window;
{
Lisp_Object new;
register struct window *o, *p;
- register struct Lisp_Vector *vec;
int i;
o = XWINDOW (window);
- vec = allocate_vectorlike ((EMACS_INT)VECSIZE (struct window));
+ p = allocate_window ();
for (i = 0; i < VECSIZE (struct window); ++i)
- vec->contents[i] = ((struct Lisp_Vector *)o)->contents[i];
- vec->size = VECSIZE (struct window);
- p = (struct window *)vec;
+ ((struct Lisp_Vector *) p)->contents[i]
+ = ((struct Lisp_Vector *)o)->contents[i];
XSETWINDOW (new, p);
XSETFASTINT (p->sequence_number, ++sequence_number);
}
DEFUN ("split-window", Fsplit_window, Ssplit_window, 0, 3, "",
- "Split WINDOW, putting SIZE lines in the first of the pair.\n\
-WINDOW defaults to selected one and SIZE to half its size.\n\
-If optional third arg HORFLAG is non-nil, split side by side\n\
-and put SIZE columns in the first of the pair. In that case,\n\
-SIZE includes that window's scroll bar, or the divider column to its right.")
- (window, size, horflag)
+ doc: /* Split WINDOW, putting SIZE lines in the first of the pair.
+WINDOW defaults to selected one and SIZE to half its size.
+If optional third arg HORFLAG is non-nil, split side by side
+and put SIZE columns in the first of the pair. In that case,
+SIZE includes that window's scroll bar, or the divider column to its right. */)
+ (window, size, horflag)
Lisp_Object window, size, horflag;
{
register Lisp_Object new;
if (NILP (window))
window = selected_window;
else
- CHECK_LIVE_WINDOW (window, 0);
+ CHECK_LIVE_WINDOW (window);
o = XWINDOW (window);
fo = XFRAME (WINDOW_FRAME (o));
}
else
{
- CHECK_NUMBER (size, 1);
+ CHECK_NUMBER (size);
size_int = XINT (size);
}
return new;
}
\f
-DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 2, "p",
- "Make current window ARG lines bigger.\n\
-From program, optional second arg non-nil means grow sideways ARG columns.")
- (arg, side)
- register Lisp_Object arg, side;
+DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 3, "p",
+ doc: /* Make current window ARG lines bigger.
+From program, optional second arg non-nil means grow sideways ARG columns.
+Interactively, if an argument is not given, make the window one line bigger.
+
+Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
+of the siblings above or to the left of the selected window. Only
+siblings to the right or below are changed. */)
+ (arg, side, preserve_before)
+ register Lisp_Object arg, side, preserve_before;
{
- CHECK_NUMBER (arg, 0);
- enlarge_window (selected_window, XINT (arg), !NILP (side));
+ CHECK_NUMBER (arg);
+ enlarge_window (selected_window, XINT (arg), !NILP (side),
+ !NILP (preserve_before));
if (! NILP (Vwindow_configuration_change_hook))
call1 (Vrun_hooks, Qwindow_configuration_change_hook);
}
DEFUN ("shrink-window", Fshrink_window, Sshrink_window, 1, 2, "p",
- "Make current window ARG lines smaller.\n\
-From program, optional second arg non-nil means shrink sideways arg columns.")
- (arg, side)
+ doc: /* Make current window ARG lines smaller.
+From program, optional second arg non-nil means shrink sideways arg columns.
+Interactively, if an argument is not given, make the window one line smaller. */)
+ (arg, side)
register Lisp_Object arg, side;
{
- CHECK_NUMBER (arg, 0);
- enlarge_window (selected_window, -XINT (arg), !NILP (side));
+ CHECK_NUMBER (arg);
+ enlarge_window (selected_window, -XINT (arg), !NILP (side), 0);
if (! NILP (Vwindow_configuration_change_hook))
call1 (Vrun_hooks, Qwindow_configuration_change_hook);
*(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
-/* Enlarge selected_window by DELTA. WIDTHFLAG non-zero means
+/* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
increase its width. Siblings of the selected window are resized to
- fullfil the size request. If they become too small in the process,
- they will be deleted. */
+ fulfill the size request. If they become too small in the process,
+ they will be deleted.
+
+ If PRESERVE_BEFORE is nonzero, that means don't alter
+ the siblings to the left or above WINDOW. */
static void
-enlarge_window (window, delta, widthflag)
+enlarge_window (window, delta, widthflag, preserve_before)
Lisp_Object window;
- int delta, widthflag;
+ int delta, widthflag, preserve_before;
{
Lisp_Object parent, next, prev;
struct window *p;
{
register int maxdelta;
- maxdelta = (!NILP (parent) ? (*sizefun) (parent) - XINT (*sizep)
- : !NILP (p->next) ? ((*sizefun) (p->next)
- - window_min_size (XWINDOW (p->next),
- widthflag, 0, 0))
- : !NILP (p->prev) ? ((*sizefun) (p->prev)
- - window_min_size (XWINDOW (p->prev),
- widthflag, 0, 0))
- /* This is a frame with only one window, a minibuffer-only
- or a minibufferless frame. */
- : (delta = 0));
+ /* Compute the maximum size increment this window can have. */
+
+ if (preserve_before)
+ {
+ if (!NILP (parent))
+ {
+ maxdelta = (*sizefun) (parent) - XINT (*sizep);
+ /* Subtract size of siblings before, since we can't take that. */
+ maxdelta -= XINT (CURBEG (window)) - XINT (CURBEG (parent));
+ }
+ else
+ maxdelta = (!NILP (p->next) ? ((*sizefun) (p->next)
+ - window_min_size (XWINDOW (p->next),
+ widthflag, 0, 0))
+ : (delta = 0));
+ }
+ else
+ maxdelta = (!NILP (parent) ? (*sizefun) (parent) - XINT (*sizep)
+ /* This is a main window followed by a minibuffer. */
+ : !NILP (p->next) ? ((*sizefun) (p->next)
+ - window_min_size (XWINDOW (p->next),
+ widthflag, 0, 0))
+ /* This is a minibuffer following a main window. */
+ : !NILP (p->prev) ? ((*sizefun) (p->prev)
+ - window_min_size (XWINDOW (p->prev),
+ widthflag, 0, 0))
+ /* This is a frame with only one window, a minibuffer-only
+ or a minibufferless frame. */
+ : (delta = 0));
if (delta > maxdelta)
/* This case traps trying to make the minibuffer
if (delta == 0)
return;
- /* Find the total we can get from other siblings. */
+ /* Find the total we can get from other siblings without deleting them. */
maximum = 0;
for (next = p->next; ! NILP (next); next = XWINDOW (next)->next)
maximum += (*sizefun) (next) - window_min_size (XWINDOW (next),
widthflag, 0, 0);
- for (prev = p->prev; ! NILP (prev); prev = XWINDOW (prev)->prev)
- maximum += (*sizefun) (prev) - window_min_size (XWINDOW (prev),
- widthflag, 0, 0);
+ if (! preserve_before)
+ for (prev = p->prev; ! NILP (prev); prev = XWINDOW (prev)->prev)
+ maximum += (*sizefun) (prev) - window_min_size (XWINDOW (prev),
+ widthflag, 0, 0);
- /* If we can get it all from them, do so. */
+ /* If we can get it all from them without deleting them, do so. */
if (delta <= maximum)
{
Lisp_Object first_unaffected;
/* Look at one sibling at a time,
moving away from this window in both directions alternately,
and take as much as we can get without deleting that sibling. */
- while (delta != 0 && (!NILP (next) || !NILP (prev)))
+ while (delta != 0
+ && (!NILP (next) || (!preserve_before && !NILP (prev))))
{
if (! NILP (next))
{
if (delta == 0)
break;
- if (! NILP (prev))
+ if (!preserve_before && ! NILP (prev))
{
int this_one = ((*sizefun) (prev)
- window_min_size (XWINDOW (prev),
register int delta1;
register int opht = (*sizefun) (parent);
- /* If trying to grow this window to or beyond size of the parent,
- make delta1 so big that, on shrinking back down,
- all the siblings end up with less than one line and are deleted. */
if (opht <= XINT (*sizep) + delta)
- delta1 = opht * opht * 2;
+ {
+ /* If trying to grow this window to or beyond size of the parent,
+ just delete all the sibling windows. */
+ Lisp_Object start, tem, next;
+
+ start = XWINDOW (parent)->vchild;
+ if (NILP (start))
+ start = XWINDOW (parent)->hchild;
+
+ /* Delete any siblings that come after WINDOW. */
+ tem = XWINDOW (window)->next;
+ while (! NILP (tem))
+ {
+ next = XWINDOW (tem)->next;
+ delete_window (tem);
+ tem = next;
+ }
+
+ /* Delete any siblings that come after WINDOW.
+ Note that if START is not WINDOW, then WINDOW still
+ Fhas siblings, so WINDOW has not yet replaced its parent. */
+ tem = start;
+ while (! EQ (tem, window))
+ {
+ next = XWINDOW (tem)->next;
+ delete_window (tem);
+ tem = next;
+ }
+ }
else
{
/* Otherwise, make delta1 just right so that if we add
++n;
delta1 = n * delta;
- }
- /* Add delta1 lines or columns to this window, and to the parent,
- keeping things consistent while not affecting siblings. */
- XSETINT (CURSIZE (parent), opht + delta1);
- (*setsizefun) (window, XINT (*sizep) + delta1, 0);
-
- /* Squeeze out delta1 lines or columns from our parent,
- shriking this window and siblings proportionately.
- This brings parent back to correct size.
- Delta1 was calculated so this makes this window the desired size,
- taking it all out of the siblings. */
- (*setsizefun) (parent, opht, 0);
+ /* Add delta1 lines or columns to this window, and to the parent,
+ keeping things consistent while not affecting siblings. */
+ XSETINT (CURSIZE (parent), opht + delta1);
+ (*setsizefun) (window, XINT (*sizep) + delta1, 0);
+
+ /* Squeeze out delta1 lines or columns from our parent,
+ shriking this window and siblings proportionately.
+ This brings parent back to correct size.
+ Delta1 was calculated so this makes this window the desired size,
+ taking it all out of the siblings. */
+ (*setsizefun) (parent, opht, 0);
+
+ }
}
XSETFASTINT (p->last_modified, 0);
{
int min_height = window_min_size (root, 0, 0, 0);
if (XFASTINT (root->height) - delta < min_height)
- delta = XFASTINT (root->height) - min_height;
+ /* Note that the root window may already be smaller than
+ min_height. */
+ delta = max (0, XFASTINT (root->height) - min_height);
}
if (delta)
}
else if (XFASTINT (w->height) > 1)
{
+ /* Distribute the additional lines of the mini-window
+ among the other windows. */
Lisp_Object window;
XSETWINDOW (window, w);
- enlarge_window (window, 1 - XFASTINT (w->height), 0);
+ enlarge_window (window, 1 - XFASTINT (w->height), 0, 0);
}
}
}
-/* Return number of lines of text (not counting mode line) in W. */
+/* Return number of lines of text (not counting mode lines) in W. */
int
window_internal_height (w)
{
int ht = XFASTINT (w->height);
- if (MINI_WINDOW_P (w))
- return ht;
-
- if (!NILP (w->parent) || !NILP (w->vchild) || !NILP (w->hchild)
- || !NILP (w->next) || !NILP (w->prev)
- || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w))))
- return ht - 1;
+ if (!MINI_WINDOW_P (w))
+ {
+ if (!NILP (w->parent)
+ || !NILP (w->vchild)
+ || !NILP (w->hchild)
+ || !NILP (w->next)
+ || !NILP (w->prev)
+ || WINDOW_WANTS_MODELINE_P (w))
+ --ht;
+
+ if (WINDOW_WANTS_HEADER_LINE_P (w))
+ --ht;
+ }
return ht;
}
width -= 1;
/* On window-systems, areas to the left and right of the window
- are used to display bitmaps there. */
+ are used as fringes. */
if (FRAME_WINDOW_P (f))
- width -= FRAME_FLAGS_AREA_COLS (f);
+ width -= FRAME_FRINGE_COLS (f);
return width;
}
***********************************************************************/
/* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
- one screen-full, which is defined as the height of the window minus
+ N screen-fulls, which is defined as the height of the window minus
next_screen_context_lines. If WHOLE is zero, scroll up N lines
instead. Negative values of N mean scroll down. NOERROR non-zero
means don't signal an error if we try to move over BEGV or ZV,
SET_TEXT_POS_FROM_MARKER (start, w->start);
/* If PT is not visible in WINDOW, move back one half of
- the screen. */
- XSETFASTINT (tem, PT);
- tem = Fpos_visible_in_window_p (tem, window, Qnil);
+ the screen. Allow PT to be partially visible, otherwise
+ something like (scroll-down 1) with PT in the line before
+ the partially visible one would recenter. */
+ tem = Fpos_visible_in_window_p (make_number (PT), window, Qt);
if (NILP (tem))
{
/* Move backward half the height of the window. Performance note:
results for variable height lines. */
init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
it.current_y = it.last_visible_y;
- move_it_vertically (&it, -it.last_visible_y / 2);
+ move_it_vertically (&it, - window_box_height (w) / 2);
/* The function move_iterator_vertically may move over more than
the specified y-distance. If it->w is small, e.g. a
start_display (&it, w, start);
if (whole)
{
- int screen_full = (it.last_visible_y
+ int screen_full = (window_box_height (w)
- next_screen_context_lines * CANON_Y_UNIT (it.f));
- int direction = n < 0 ? -1 : 1;
- move_it_vertically (&it, direction * screen_full);
+ int dy = n * screen_full;
+
+ /* 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);
+ else if (dy > 0)
+ move_it_to (&it, ZV, -1, it.current_y + dy, -1,
+ MOVE_TO_POS | MOVE_TO_Y);
}
else
move_it_by_lines (&it, n, 1);
{
if (it.current_y + it.max_ascent + it.max_descent
> it.last_visible_y)
- /* The last line was only partially visible, make it fully
- visible. */
- w->vscroll =
- it.last_visible_y
- - it.current_y + it.max_ascent + it.max_descent;
+ {
+ /* The last line was only partially visible, make it fully
+ visible. */
+ w->vscroll = (it.last_visible_y
+ - it.current_y + it.max_ascent + it.max_descent);
+ adjust_glyphs (it.f);
+ }
else if (noerror)
return;
else
if (! vscrolled)
{
+ int pos = IT_CHARPOS (it);
+ int bytepos;
/* Set the window start, and set up the window for redisplay. */
- set_marker_restricted (w->start, make_number (IT_CHARPOS (it)),
+ set_marker_restricted (w->start, make_number (pos),
w->buffer);
- w->start_at_line_beg = Fbolp ();
+ bytepos = XMARKER (w->start)->bytepos;
+ w->start_at_line_beg = ((pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n')
+ ? Qt : Qnil);
w->update_mode_line = Qt;
XSETFASTINT (w->last_modified, 0);
XSETFASTINT (w->last_overlay_modified, 0);
in the scroll margin at the top. */
move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
while (it.current_y < this_scroll_margin)
- move_it_by_lines (&it, 1, 1);
+ {
+ int prev = it.current_y;
+ move_it_by_lines (&it, 1, 1);
+ if (prev == it.current_y)
+ break;
+ }
SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
}
else if (n < 0)
struct position posit;
int original_vpos;
+ /* If scrolling screen-fulls, compute the number of lines to
+ scroll from the window's height. */
+ if (whole)
+ n *= max (1, ht - next_screen_context_lines);
+
startpos = marker_position (w->start);
posit = *compute_motion (startpos, 0, 0, 0,
Lisp_Object n;
int direction;
{
- register int defalt;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
xassert (abs (direction) == 1);
++windows_or_buffers_changed;
}
- defalt = (window_internal_height (XWINDOW (selected_window))
- - next_screen_context_lines);
- defalt = direction * (defalt < 1 ? 1 : defalt);
-
if (NILP (n))
- window_scroll (selected_window, defalt, 1, 0);
+ window_scroll (selected_window, direction, 1, 0);
else if (EQ (n, Qminus))
- window_scroll (selected_window, - defalt, 1, 0);
+ window_scroll (selected_window, -direction, 1, 0);
else
{
n = Fprefix_numeric_value (n);
}
DEFUN ("scroll-up", Fscroll_up, Sscroll_up, 0, 1, "P",
- "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
-A near full screen is `next-screen-context-lines' less than a full screen.\n\
-Negative ARG means scroll downward.\n\
-If ARG is the atom `-', scroll downward by nearly full screen.\n\
-When calling from a program, supply as argument a number, nil, or `-'.")
- (arg)
+ doc: /* Scroll text of current window upward ARG lines; or near full screen if no ARG.
+A near full screen is `next-screen-context-lines' less than a full screen.
+Negative ARG means scroll downward.
+If ARG is the atom `-', scroll downward by nearly full screen.
+When calling from a program, supply as argument a number, nil, or `-'. */)
+ (arg)
Lisp_Object arg;
{
scroll_command (arg, 1);
}
DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "P",
- "Scroll text of current window down ARG lines; or near full screen if no ARG.\n\
-A near full screen is `next-screen-context-lines' less than a full screen.\n\
-Negative ARG means scroll upward.\n\
-If ARG is the atom `-', scroll upward by nearly full screen.\n\
-When calling from a program, supply as argument a number, nil, or `-'.")
- (arg)
+ doc: /* Scroll text of current window down ARG lines; or near full screen if no ARG.
+A near full screen is `next-screen-context-lines' less than a full screen.
+Negative ARG means scroll upward.
+If ARG is the atom `-', scroll upward by nearly full screen.
+When calling from a program, supply as argument a number, nil, or `-'. */)
+ (arg)
Lisp_Object arg;
{
scroll_command (arg, -1);
}
\f
DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, Sother_window_for_scrolling, 0, 0, 0,
- "Return the other window for \"other window scroll\" commands.\n\
-If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
-specifies the window.\n\
-If `other-window-scroll-buffer' is non-nil, a window\n\
-showing that buffer is used.")
- ()
+ doc: /* Return the other window for \"other window scroll\" commands.
+If in the minibuffer, `minibuffer-scroll-window' if non-nil
+specifies the window.
+If `other-window-scroll-buffer' is non-nil, a window
+showing that buffer is used. */)
+ ()
{
Lisp_Object window;
&& ! EQ (window, selected_window));
}
- CHECK_LIVE_WINDOW (window, 0);
+ CHECK_LIVE_WINDOW (window);
if (EQ (window, selected_window))
error ("There is no other window");
}
DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "P",
- "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
-A near full screen is `next-screen-context-lines' less than a full screen.\n\
-The next window is the one below the current one; or the one at the top\n\
-if the current one is at the bottom. Negative ARG means scroll downward.\n\
-If ARG is the atom `-', scroll downward by nearly full screen.\n\
-When calling from a program, supply as argument a number, nil, or `-'.\n\
-\n\
-If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
-specifies the window to scroll.\n\
-If `other-window-scroll-buffer' is non-nil, scroll the window\n\
-showing that buffer, popping the buffer up if necessary.")
- (arg)
- register Lisp_Object arg;
+ doc: /* Scroll next window upward ARG lines; or near full screen if no ARG.
+A near full screen is `next-screen-context-lines' less than a full screen.
+The next window is the one below the current one; or the one at the top
+if the current one is at the bottom. Negative ARG means scroll downward.
+If ARG is the atom `-', scroll downward by nearly full screen.
+When calling from a program, supply as argument a number, nil, or `-'.
+
+If in the minibuffer, `minibuffer-scroll-window' if non-nil
+specifies the window to scroll.
+If `other-window-scroll-buffer' is non-nil, scroll the window
+showing that buffer, popping the buffer up if necessary. */)
+ (arg)
+ Lisp_Object arg;
{
- register Lisp_Object window;
- register int defalt;
- register struct window *w;
- register int count = specpdl_ptr - specpdl;
+ Lisp_Object window;
+ struct window *w;
+ int count = SPECPDL_INDEX ();
window = Fother_window_for_scrolling ();
-
w = XWINDOW (window);
- defalt = window_internal_height (w) - next_screen_context_lines;
- if (defalt < 1) defalt = 1;
/* Don't screw up if window_scroll gets an error. */
record_unwind_protect (save_excursion_restore, save_excursion_save ());
SET_PT (marker_position (w->pointm));
if (NILP (arg))
- window_scroll (window, defalt, 1, 1);
+ window_scroll (window, 1, 1, 1);
else if (EQ (arg, Qminus))
- window_scroll (window, -defalt, 1, 1);
+ window_scroll (window, -1, 1, 1);
else
{
if (CONSP (arg))
arg = Fcar (arg);
- CHECK_NUMBER (arg, 0);
+ CHECK_NUMBER (arg);
window_scroll (window, XINT (arg), 0, 1);
}
}
\f
DEFUN ("scroll-left", Fscroll_left, Sscroll_left, 0, 1, "P",
- "Scroll selected window display ARG columns left.\n\
-Default for ARG is window width minus 2.")
- (arg)
+ doc: /* Scroll selected window display ARG columns left.
+Default for ARG is window width minus 2.
+Value is the total amount of leftward horizontal scrolling in
+effect after the change.
+If `automatic-hscrolling' is non-nil, the argument ARG modifies
+a lower bound for automatic scrolling, i.e. automatic scrolling
+will not scroll a window to a column less than the value returned
+by this function. */)
+ (arg)
register Lisp_Object arg;
{
-
+ Lisp_Object result;
+ int hscroll;
+ struct window *w = XWINDOW (selected_window);
+
if (NILP (arg))
- XSETFASTINT (arg, window_internal_width (XWINDOW (selected_window)) - 2);
+ XSETFASTINT (arg, window_internal_width (w) - 2);
else
arg = Fprefix_numeric_value (arg);
- return
- Fset_window_hscroll (selected_window,
- make_number (XINT (XWINDOW (selected_window)->hscroll)
- + XINT (arg)));
+ hscroll = XINT (w->hscroll) + XINT (arg);
+ result = Fset_window_hscroll (selected_window, make_number (hscroll));
+
+ if (interactive_p (0))
+ w->min_hscroll = w->hscroll;
+
+ return result;
}
DEFUN ("scroll-right", Fscroll_right, Sscroll_right, 0, 1, "P",
- "Scroll selected window display ARG columns right.\n\
-Default for ARG is window width minus 2.")
- (arg)
+ doc: /* Scroll selected window display ARG columns right.
+Default for ARG is window width minus 2.
+Value is the total amount of leftward horizontal scrolling in
+effect after the change.
+If `automatic-hscrolling' is non-nil, the argument ARG modifies
+a lower bound for automatic scrolling, i.e. automatic scrolling
+will not scroll a window to a column less than the value returned
+by this function. */)
+ (arg)
register Lisp_Object arg;
{
+ Lisp_Object result;
+ int hscroll;
+ struct window *w = XWINDOW (selected_window);
+
if (NILP (arg))
- XSETFASTINT (arg, window_internal_width (XWINDOW (selected_window)) - 2);
+ XSETFASTINT (arg, window_internal_width (w) - 2);
else
arg = Fprefix_numeric_value (arg);
- return
- Fset_window_hscroll (selected_window,
- make_number (XINT (XWINDOW (selected_window)->hscroll)
- - XINT (arg)));
+ hscroll = XINT (w->hscroll) - XINT (arg);
+ result = Fset_window_hscroll (selected_window, make_number (hscroll));
+
+ if (interactive_p (0))
+ w->min_hscroll = w->hscroll;
+
+ return result;
}
-DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
- "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
-The desired position of point is always relative to the current window.\n\
-Just C-u as prefix means put point in the center of the window.\n\
-If ARG is omitted or nil, erases the entire frame and then\n\
-redraws with point in the center of the current window.")
- (arg)
- register Lisp_Object arg;
+DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window, Sminibuffer_selected_window, 0, 0, 0,
+ doc: /* Return the window which was selected when entering the minibuffer.
+Returns nil, if current window is not a minibuffer window. */)
+ ()
{
- register struct window *w = XWINDOW (selected_window);
- register int ht = window_internal_height (w);
- struct position pos;
- struct buffer *buf = XBUFFER (w->buffer);
- struct buffer *obuf = current_buffer;
-
- if (NILP (arg))
- {
- extern int frame_garbaged;
- int i;
-
- /* Invalidate pixel data calculated for all compositions. */
- for (i = 0; i < n_compositions; i++)
- composition_table[i]->font = NULL;
-
- Fredraw_frame (w->frame);
- SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w)));
- XSETFASTINT (arg, ht / 2);
- }
- else if (CONSP (arg)) /* Just C-u. */
- {
- XSETFASTINT (arg, ht / 2);
- }
- else
- {
- arg = Fprefix_numeric_value (arg);
- CHECK_NUMBER (arg, 0);
- }
-
- if (XINT (arg) < 0)
- XSETINT (arg, XINT (arg) + ht);
-
- set_buffer_internal (buf);
- pos = *vmotion (PT, - XINT (arg), w);
-
- set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
- w->start_at_line_beg = ((pos.bytepos == BEGV_BYTE
- || FETCH_BYTE (pos.bytepos - 1) == '\n')
- ? Qt : Qnil);
- w->force_start = Qt;
- set_buffer_internal (obuf);
+ if (minibuf_level > 0
+ && MINI_WINDOW_P (XWINDOW (selected_window))
+ && !NILP (minibuf_selected_window)
+ && WINDOW_LIVE_P (minibuf_selected_window))
+ return minibuf_selected_window;
return Qnil;
}
-
/* Value is the number of lines actually displayed in window W,
as opposed to its height. */
else
old_buffer = NULL;
- SET_TEXT_POS_FROM_MARKER (start, w->start);
+ /* In case W->start is out of the accessible range, do something
+ reasonable. This happens in Info mode when Info-scroll-down
+ calls (recenter -1) while W->start is 1. */
+ if (XMARKER (w->start)->charpos < BEGV)
+ SET_TEXT_POS (start, BEGV, BEGV_BYTE);
+ else if (XMARKER (w->start)->charpos > ZV)
+ SET_TEXT_POS (start, ZV, ZV_BYTE);
+ else
+ SET_TEXT_POS_FROM_MARKER (start, w->start);
+
start_display (&it, w, start);
move_it_vertically (&it, height);
+ bottom_y = line_bottom_y (&it);
+
+ /* rms: On a non-window display,
+ the value of it.vpos at the bottom of the screen
+ seems to be 1 larger than window_box_height (w).
+ This kludge fixes a bug whereby (move-to-window-line -1)
+ when ZV is on the last screen line
+ moves to the previous screen line instead of the last one. */
+ if (! FRAME_WINDOW_P (XFRAME (w->frame)))
+ height++;
+
+ /* Add in empty lines at the bottom of the window. */
+ if (bottom_y < height)
+ {
+ int uy = CANON_Y_UNIT (it.f);
+ it.vpos += (height - bottom_y + uy - 1) / uy;
+ }
if (old_buffer)
set_buffer_internal (old_buffer);
- bottom_y = it.current_y + it.max_ascent + it.max_descent;
+ return it.vpos;
+}
- if (bottom_y > it.current_y && bottom_y <= it.last_visible_y)
- /* Hit a line without a terminating newline. */
- it.vpos++;
- /* Add in empty lines at the bottom of the window. */
- if (bottom_y < height)
+DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
+ doc: /* Center point in window and redisplay frame.
+With prefix argument ARG, recenter putting point on screen line ARG
+relative to the current window. If ARG is negative, it counts up from the
+bottom of the window. (ARG should be less than the height of the window.)
+
+If ARG is omitted or nil, erase the entire frame and then
+redraw with point in the center of the current window.
+Just C-u as prefix means put point in the center of the window
+and redisplay normally--don't erase and redraw the frame. */)
+ (arg)
+ register Lisp_Object arg;
+{
+ struct window *w = XWINDOW (selected_window);
+ struct buffer *buf = XBUFFER (w->buffer);
+ struct buffer *obuf = current_buffer;
+ int center_p = 0;
+ int charpos, bytepos;
+
+ /* If redisplay is suppressed due to an error, try again. */
+ obuf->display_error_modiff = 0;
+
+ if (NILP (arg))
{
- struct frame *f = XFRAME (w->frame);
- int rest = height - bottom_y;
- int lines = rest / CANON_Y_UNIT (f);
- it.vpos += lines;
+ int i;
+
+ /* Invalidate pixel data calculated for all compositions. */
+ for (i = 0; i < n_compositions; i++)
+ composition_table[i]->font = NULL;
+
+ Fredraw_frame (w->frame);
+ SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w)));
+ center_p = 1;
+ }
+ else if (CONSP (arg)) /* Just C-u. */
+ center_p = 1;
+ else
+ {
+ arg = Fprefix_numeric_value (arg);
+ CHECK_NUMBER (arg);
}
- return it.vpos;
+ set_buffer_internal (buf);
+
+ /* 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. */
+ if (FRAME_WINDOW_P (XFRAME (w->frame)))
+ {
+ if (center_p)
+ {
+ struct it it;
+ struct text_pos pt;
+
+ SET_TEXT_POS (pt, PT, PT_BYTE);
+ start_display (&it, w, pt);
+ move_it_vertically (&it, - window_box_height (w) / 2);
+ charpos = IT_CHARPOS (it);
+ bytepos = IT_BYTEPOS (it);
+ }
+ else if (XINT (arg) < 0)
+ {
+ struct it it;
+ struct text_pos pt;
+ int y0, y1, h, nlines;
+
+ SET_TEXT_POS (pt, PT, PT_BYTE);
+ start_display (&it, w, pt);
+ y0 = it.current_y;
+
+ /* The amount of pixels we have to move back is the window
+ height minus what's displayed in the line containing PT,
+ and the lines below. */
+ nlines = - XINT (arg) - 1;
+ move_it_by_lines (&it, nlines, 1);
+
+ y1 = line_bottom_y (&it);
+
+ /* If we can't move down NLINES lines because we hit
+ the end of the buffer, count in some empty lines. */
+ if (it.vpos < nlines)
+ y1 += (nlines - it.vpos) * CANON_Y_UNIT (it.f);
+
+ h = window_box_height (w) - (y1 - y0);
+
+ start_display (&it, w, pt);
+ move_it_vertically (&it, - h);
+ charpos = IT_CHARPOS (it);
+ bytepos = IT_BYTEPOS (it);
+ }
+ else
+ {
+ struct position pos;
+ pos = *vmotion (PT, - XINT (arg), w);
+ charpos = pos.bufpos;
+ bytepos = pos.bytepos;
+ }
+ }
+ else
+ {
+ struct position pos;
+ 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);
+
+ pos = *vmotion (PT, - XINT (arg), w);
+ charpos = pos.bufpos;
+ bytepos = pos.bytepos;
+ }
+
+ /* Set the new window start. */
+ set_marker_both (w->start, w->buffer, charpos, bytepos);
+ w->window_end_valid = Qnil;
+
+ w->optional_new_start = Qt;
+
+ if (bytepos == BEGV_BYTE || FETCH_BYTE (bytepos - 1) == '\n')
+ w->start_at_line_beg = Qt;
+ else
+ w->start_at_line_beg = Qnil;
+
+ set_buffer_internal (obuf);
+ return Qnil;
}
DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
- 0, 1, 0,
- "Return the height in lines of the text display area of WINDOW.\n\
-This doesn't include the mode-line (or header-line if any) or any\n\
-partial-height lines in the text display area.")
- (window)
+ 0, 1, 0,
+ doc: /* Return the height in lines of the text display area of WINDOW.
+This doesn't include the mode-line (or header-line if any) or any
+partial-height lines in the text display area. */)
+ (window)
Lisp_Object window;
{
struct window *w = decode_window (window);
\f
DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
- 1, 1, "P",
- "Position point relative to window.\n\
-With no argument, position point at center of window.\n\
-An argument specifies vertical position within the window;\n\
-zero means top of window, negative means relative to bottom of window.")
- (arg)
+ 1, 1, "P",
+ doc: /* Position point relative to window.
+With no argument, position point at center of window.
+An argument specifies vertical position within the window;
+zero means top of window, negative means relative to bottom of window. */)
+ (arg)
Lisp_Object arg;
{
struct window *w = XWINDOW (selected_window);
XSETINT (arg, XINT (arg) + lines);
}
+ /* Skip past a partially visible first line. */
if (w->vscroll)
- /* Skip past a partially visible first line. */
XSETINT (arg, XINT (arg) + 1);
return Fvertical_motion (arg, window);
Lisp_Object current_window;
Lisp_Object current_buffer;
Lisp_Object minibuf_scroll_window;
+ Lisp_Object minibuf_selected_window;
Lisp_Object root_window;
Lisp_Object focus_frame;
/* Record the values of window-min-width and window-min-height
/* This is saved as a Lisp_Vector */
struct saved_window
- {
- /* these first two must agree with struct Lisp_Vector in lisp.h */
- EMACS_INT size_from_Lisp_Vector_struct;
- struct Lisp_Vector *next_from_Lisp_Vector_struct;
+{
+ /* these first two must agree with struct Lisp_Vector in lisp.h */
+ EMACS_INT size_from_Lisp_Vector_struct;
+ struct Lisp_Vector *next_from_Lisp_Vector_struct;
- Lisp_Object window;
- Lisp_Object buffer, start, pointm, mark;
- Lisp_Object left, top, width, height, hscroll;
- Lisp_Object parent, prev;
- Lisp_Object start_at_line_beg;
- Lisp_Object display_table;
- Lisp_Object orig_top, orig_height;
- };
-#define SAVED_WINDOW_VECTOR_SIZE 16 /* Arg to Fmake_vector */
+ Lisp_Object window;
+ Lisp_Object buffer, start, pointm, mark;
+ Lisp_Object left, top, width, height, hscroll, min_hscroll;
+ Lisp_Object parent, prev;
+ Lisp_Object start_at_line_beg;
+ Lisp_Object display_table;
+ Lisp_Object orig_top, orig_height;
+};
+
+#define SAVED_WINDOW_VECTOR_SIZE 17 /* Arg to Fmake_vector */
#define SAVED_WINDOW_N(swv,n) \
((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
- "Return t if OBJECT is a window-configuration object.")
- (object)
+ doc: /* Return t if OBJECT is a window-configuration object. */)
+ (object)
Lisp_Object object;
{
if (WINDOW_CONFIGURATIONP (object))
}
DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_configuration_frame, 1, 1, 0,
- "Return the frame that CONFIG, a window-configuration object, is about.")
- (config)
+ doc: /* Return the frame that CONFIG, a window-configuration object, is about. */)
+ (config)
Lisp_Object config;
{
register struct save_window_data *data;
}
DEFUN ("set-window-configuration", Fset_window_configuration,
- Sset_window_configuration, 1, 1, 0,
- "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
-CONFIGURATION must be a value previously returned\n\
-by `current-window-configuration' (which see).\n\
-If CONFIGURATION was made from a frame that is now deleted,\n\
-only frame-independent values can be restored. In this case,\n\
-the return value is nil. Otherwise the value is t.")
- (configuration)
+ Sset_window_configuration, 1, 1, 0,
+ doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
+CONFIGURATION must be a value previously returned
+by `current-window-configuration' (which see).
+If CONFIGURATION was made from a frame that is now deleted,
+only frame-independent values can be restored. In this case,
+the return value is nil. Otherwise the value is t. */)
+ (configuration)
Lisp_Object configuration;
{
register struct save_window_data *data;
if (NILP (XBUFFER (new_current_buffer)->name))
new_current_buffer = Qnil;
else
- {
- if (XBUFFER (new_current_buffer) == current_buffer)
- old_point = PT;
- }
+ old_point = BUF_PT (XBUFFER (new_current_buffer));
frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
f = XFRAME (frame);
-
+
/* If f is a dead frame, don't bother rebuilding its window tree.
However, there is other stuff we should still try to do below. */
if (FRAME_LIVE_P (f))
w->width = p->width;
w->height = p->height;
w->hscroll = p->hscroll;
+ w->min_hscroll = p->min_hscroll;
w->display_table = p->display_table;
w->orig_top = p->orig_top;
w->orig_height = p->orig_height;
p->mark, w->buffer);
/* As documented in Fcurrent_window_configuration, don't
- save the location of point in the buffer which was current
- when the window configuration was recorded. */
+ restore the location of point in the buffer which was
+ current when the window configuration was recorded. */
if (!EQ (p->buffer, new_current_buffer)
&& XBUFFER (p->buffer) == current_buffer)
Fgoto_char (w->pointm);
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.
- That swapping out has already been done,
- near the beginning of this function. */
+ Use the point value from the beginning of this function
+ since unshow_buffer (called from delete_all_subwindows)
+ could have altered it. */
selected_window = Qnil;
+ if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
+ set_marker_restricted (XWINDOW (data->current_window)->pointm,
+ make_number (old_point),
+ XWINDOW (data->current_window)->buffer);
+
Fselect_window (data->current_window);
XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
= selected_window;
when the frame's old selected window has been deleted. */
if (f != selected_frame && FRAME_WINDOW_P (f))
do_switch_frame (WINDOW_FRAME (XWINDOW (data->root_window)),
- Qnil, 0);
+ 0, 0);
#endif
/* Set the screen height to the value it had before this function. */
xassert (NILP (leaf_windows[i]->hchild)
&& NILP (leaf_windows[i]->vchild));
free_window_matrices (leaf_windows[i]);
- SET_FRAME_GARBAGED (f);
}
else if (EQ (leaf_windows[i]->buffer, new_current_buffer))
++n;
}
-
- /* If more than one window shows the new and old current buffer,
- don't try to preserve point in that buffer. */
- if (old_point > 0 && n > 1)
- old_point = -1;
adjust_glyphs (f);
Fselect_window above totally superfluous; it still sets f's
selected window. */
if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
- do_switch_frame (data->selected_frame, Qnil, 0);
+ do_switch_frame (data->selected_frame, 0, 0);
if (! NILP (Vwindow_configuration_change_hook)
&& ! NILP (Vrun_hooks))
}
if (!NILP (new_current_buffer))
- {
- Fset_buffer (new_current_buffer);
-
- /* If the buffer that is current now is the same
- that was current before setting the window configuration,
- don't alter its PT. */
- if (old_point >= 0)
- SET_PT (old_point);
- }
+ Fset_buffer (new_current_buffer);
/* Restore the minimum heights recorded in the configuration. */
window_min_height = XINT (data->min_height);
window_min_width = XINT (data->min_width);
Vminibuf_scroll_window = data->minibuf_scroll_window;
+ minibuf_selected_window = data->minibuf_selected_window;
return (FRAME_LIVE_P (f) ? Qt : Qnil);
}
p->width = w->width;
p->height = w->height;
p->hscroll = w->hscroll;
+ p->min_hscroll = w->min_hscroll;
p->display_table = w->display_table;
p->orig_top = w->orig_top;
p->orig_height = w->orig_height;
}
DEFUN ("current-window-configuration", Fcurrent_window_configuration,
- Scurrent_window_configuration, 0, 1, 0,
- "Return an object representing the current window configuration of FRAME.\n\
-If FRAME is nil or omitted, use the selected frame.\n\
-This describes the number of windows, their sizes and current buffers,\n\
-and for each displayed buffer, where display starts, and the positions of\n\
-point and mark. An exception is made for point in the current buffer:\n\
-its value is -not- saved.\n\
-This also records the currently selected frame, and FRAME's focus\n\
-redirection (see `redirect-frame-focus').")
- (frame)
+ Scurrent_window_configuration, 0, 1, 0,
+ doc: /* Return an object representing the current window configuration of FRAME.
+If FRAME is nil or omitted, use the selected frame.
+This describes the number of windows, their sizes and current buffers,
+and for each displayed buffer, where display starts, and the positions of
+point and mark. An exception is made for point in the current buffer:
+its value is -not- saved.
+This also records the currently selected frame, and FRAME's focus
+redirection (see `redirect-frame-focus'). */)
+ (frame)
Lisp_Object frame;
{
register Lisp_Object tem;
if (NILP (frame))
frame = selected_frame;
- CHECK_LIVE_FRAME (frame, 0);
+ CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
- vec = allocate_vectorlike (VECSIZE (struct save_window_data));
- for (i = 0; i < VECSIZE (struct save_window_data); i++)
- vec->contents[i] = Qnil;
- vec->size = VECSIZE (struct save_window_data);
+ vec = allocate_other_vector (VECSIZE (struct save_window_data));
data = (struct save_window_data *)vec;
XSETFASTINT (data->frame_width, FRAME_WIDTH (f));
data->selected_frame = selected_frame;
data->current_window = FRAME_SELECTED_WINDOW (f);
XSETBUFFER (data->current_buffer, current_buffer);
- data->minibuf_scroll_window = Vminibuf_scroll_window;
+ data->minibuf_scroll_window = minibuf_level > 0 ? Vminibuf_scroll_window : Qnil;
+ data->minibuf_selected_window = minibuf_level > 0 ? minibuf_selected_window : Qnil;
data->root_window = FRAME_ROOT_WINDOW (f);
data->focus_frame = FRAME_FOCUS_FRAME (f);
XSETINT (data->min_height, window_min_height);
}
DEFUN ("save-window-excursion", Fsave_window_excursion, Ssave_window_excursion,
- 0, UNEVALLED, 0,
- "Execute body, preserving window sizes and contents.\n\
-Restore which buffer appears in which window, where display starts,\n\
-and the value of point and mark for each window.\n\
-Also restore the choice of selected window.\n\
-Also restore which buffer is current.\n\
-Does not restore the value of point in current buffer.")
- (args)
+ 0, UNEVALLED, 0,
+ doc: /* Execute body, preserving window sizes and contents.
+Restore which buffer appears in which window, where display starts,
+and the value of point and mark for each window.
+Also restore the choice of selected window.
+Also restore which buffer is current.
+Does not restore the value of point in current buffer.
+usage: (save-window-excursion BODY ...) */)
+ (args)
Lisp_Object args;
{
register Lisp_Object val;
- register int count = specpdl_ptr - specpdl;
+ register int count = SPECPDL_INDEX ();
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (Qnil));
DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
2, 3, 0,
- "Set width of marginal areas of window WINDOW.\n\
-If window is nil, set margins of the currently selected window.\n\
-First parameter LEFT-WIDTH specifies the number of character\n\
-cells to reserve for the left marginal area. Second parameter\n\
-RIGHT-WIDTH does the same for the right marginal area.\n\
-A nil width parameter means no margin.")
- (window, left, right)
+ doc: /* Set width of marginal areas of window WINDOW.
+If window is nil, set margins of the currently selected window.
+First parameter LEFT-WIDTH specifies the number of character
+cells to reserve for the left marginal area. Second parameter
+RIGHT-WIDTH does the same for the right marginal area.
+A nil width parameter means no margin. */)
+ (window, left, right)
Lisp_Object window, left, right;
{
struct window *w = decode_window (window);
if (!NILP (left))
- CHECK_NUMBER_OR_FLOAT (left, 1);
+ CHECK_NUMBER_OR_FLOAT (left);
if (!NILP (right))
- CHECK_NUMBER_OR_FLOAT (right, 2);
+ CHECK_NUMBER_OR_FLOAT (right);
/* Check widths < 0 and translate a zero width to nil.
Margins that are too wide have to be checked elsewhere. */
DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
0, 1, 0,
- "Get width of marginal areas of window WINDOW.\n\
-If WINDOW is omitted or nil, use the currently selected window.\n\
-Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).\n\
-If a marginal area does not exist, its width will be returned\n\
-as nil.")
- (window)
+ doc: /* Get width of marginal areas of window WINDOW.
+If WINDOW is omitted or nil, use the currently selected window.
+Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
+If a marginal area does not exist, its width will be returned
+as nil. */)
+ (window)
Lisp_Object window;
{
struct window *w = decode_window (window);
***********************************************************************/
DEFUN ("window-vscroll", Fwindow_vscroll, Swindow_vscroll, 0, 1, 0,
- "Return the amount by which WINDOW is scrolled vertically.\n\
-Use the selected window if WINDOW is nil or omitted.\n\
-Value is a multiple of the canonical character height of WINDOW.")
- (window)
+ doc: /* Return the amount by which WINDOW is scrolled vertically.
+Use the selected window if WINDOW is nil or omitted.
+Value is a multiple of the canonical character height of WINDOW. */)
+ (window)
Lisp_Object window;
{
Lisp_Object result;
if (NILP (window))
window = selected_window;
else
- CHECK_WINDOW (window, 0);
+ CHECK_WINDOW (window);
w = XWINDOW (window);
f = XFRAME (w->frame);
DEFUN ("set-window-vscroll", Fset_window_vscroll, Sset_window_vscroll,
2, 2, 0,
- "Set amount by which WINDOW should be scrolled vertically to VSCROLL.\n\
-WINDOW nil or omitted means use the selected window. VSCROLL is a\n\
-non-negative multiple of the canonical character height of WINDOW.")
- (window, vscroll)
+ doc: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
+WINDOW nil means use the selected window. VSCROLL is a non-negative
+multiple of the canonical character height of WINDOW. */)
+ (window, vscroll)
Lisp_Object window, vscroll;
{
struct window *w;
if (NILP (window))
window = selected_window;
else
- CHECK_WINDOW (window, 0);
- CHECK_NUMBER_OR_FLOAT (vscroll, 1);
+ CHECK_WINDOW (window);
+ CHECK_NUMBER_OR_FLOAT (vscroll);
w = XWINDOW (window);
f = XFRAME (w->frame);
}
-/* Freeze or unfreeze the window start of W if unless it is a
+/* Freeze or unfreeze the window start of W unless it is a
mini-window or the selected window. FREEZE_P non-null means freeze
the window start. */
if (! EQ (d1->current_buffer, d2->current_buffer))
return 0;
if (! ignore_positions)
- if (! EQ (d1->minibuf_scroll_window, d2->minibuf_scroll_window))
- return 0;
+ {
+ if (! EQ (d1->minibuf_scroll_window, d2->minibuf_scroll_window))
+ return 0;
+ if (! EQ (d1->minibuf_selected_window, d2->minibuf_selected_window))
+ return 0;
+ }
/* Don't compare the root_window field.
We don't require the two configurations
to use the same window object,
{
if (! EQ (p1->hscroll, p2->hscroll))
return 0;
+ if (!EQ (p1->min_hscroll, p2->min_hscroll))
+ return 0;
if (! EQ (p1->start_at_line_beg, p2->start_at_line_beg))
return 0;
if (NILP (Fequal (p1->start, p2->start)))
DEFUN ("compare-window-configurations", Fcompare_window_configurations,
Scompare_window_configurations, 2, 2, 0,
- "Compare two window configurations as regards the structure of windows.\n\
-This function ignores details such as the values of point and mark\n\
-and scrolling positions.")
- (x, y)
+ doc: /* Compare two window configurations as regards the structure of windows.
+This function ignores details such as the values of point and mark
+and scrolling positions. */)
+ (x, y)
Lisp_Object x, y;
{
if (compare_window_configurations (x, y, 1))
void
syms_of_window ()
{
- Qleft_bitmap_area = intern ("left-bitmap-area");
- staticpro (&Qleft_bitmap_area);
- Qright_bitmap_area = intern ("right-bitmap-area");
- staticpro (&Qright_bitmap_area);
-
Qwindow_size_fixed = intern ("window-size-fixed");
staticpro (&Qwindow_size_fixed);
staticpro (&Vwindow_list);
+ minibuf_selected_window = Qnil;
+ staticpro (&minibuf_selected_window);
+
DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
- "Non-nil means call as function to display a help buffer.\n\
-The function is called with one argument, the buffer to be displayed.\n\
-Used by `with-output-to-temp-buffer'.\n\
-If this function is used, then it must do the entire job of showing\n\
-the buffer; `temp-buffer-show-hook' is not run unless this function runs it.");
+ doc: /* Non-nil means call as function to display a help buffer.
+The function is called with one argument, the buffer to be displayed.
+Used by `with-output-to-temp-buffer'.
+If this function is used, then it must do the entire job of showing
+the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
Vtemp_buffer_show_function = Qnil;
DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function,
- "If non-nil, function to call to handle `display-buffer'.\n\
-It will receive two args, the buffer and a flag which if non-nil means\n\
- that the currently selected window is not acceptable.\n\
-Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
-work using this function.");
+ doc: /* If non-nil, function to call to handle `display-buffer'.
+It will receive two args, the buffer and a flag which if non-nil means
+ that the currently selected window is not acceptable.
+Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
+work using this function. */);
Vdisplay_buffer_function = Qnil;
DEFVAR_LISP ("even-window-heights", &Veven_window_heights,
- "*If non-nil, `display-buffer' should even the window heights.\n\
-If nil, `display-buffer' will leave the window configuration alone.");
+ doc: /* *If non-nil, `display-buffer' should even the window heights.
+If nil, `display-buffer' will leave the window configuration alone. */);
Veven_window_heights = Qt;
DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window,
- "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
+ doc: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
Vminibuf_scroll_window = Qnil;
+ DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows,
+ doc: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
+If the minibuffer is active, the `minibuffer-scroll-window' mode line
+is displayed in the `mode-line' face. */);
+ mode_line_in_non_selected_windows = 1;
+
DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer,
- "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
+ doc: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
Vother_window_scroll_buffer = Qnil;
DEFVAR_BOOL ("pop-up-frames", &pop_up_frames,
- "*Non-nil means `display-buffer' should make a separate frame.");
+ doc: /* *Non-nil means `display-buffer' should make a separate frame. */);
pop_up_frames = 0;
DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames,
- "*Non-nil means `display-buffer' should reuse frames.\n\
-If the buffer in question is already displayed in a frame, raise that frame.");
+ doc: /* *Non-nil means `display-buffer' should reuse frames.
+If the buffer in question is already displayed in a frame, raise that frame. */);
display_buffer_reuse_frames = 0;
DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function,
- "Function to call to handle automatic new frame creation.\n\
-It is called with no arguments and should return a newly created frame.\n\
-\n\
-A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
-where `pop-up-frame-alist' would hold the default frame parameters.");
+ doc: /* Function to call to handle automatic new frame creation.
+It is called with no arguments and should return a newly created frame.
+
+A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
+where `pop-up-frame-alist' would hold the default frame parameters. */);
Vpop_up_frame_function = Qnil;
DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names,
- "*List of buffer names that should have their own special frames.\n\
-Displaying a buffer whose name is in this list makes a special frame for it\n\
-using `special-display-function'. See also `special-display-regexps'.\n\
-\n\
-An element of the list can be a list instead of just a string.\n\
-There are two ways to use a list as an element:\n\
- (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)\n\
-In the first case, FRAME-PARAMETERS are used to create the frame.\n\
-In the latter case, FUNCTION is called with BUFFER as the first argument,\n\
-followed by OTHER-ARGS--it can display BUFFER in any way it likes.\n\
-All this is done by the function found in `special-display-function'.\n\
-\n\
-If this variable appears \"not to work\", because you add a name to it\n\
-but that buffer still appears in the selected window, look at the\n\
-values of `same-window-buffer-names' and `same-window-regexps'.\n\
-Those variables take precedence over this one.");
+ 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
+using `special-display-function'. See also `special-display-regexps'.
+
+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:
+ (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
+In the first case, FRAME-PARAMETERS are used to create the frame.
+In the latter case, FUNCTION is called with BUFFER as the first argument,
+followed by OTHER-ARGS--it can display BUFFER in any way it likes.
+All this is done by the function found in `special-display-function'.
+
+If this variable appears \"not to work\", because you add a name to it
+but that buffer still appears in the selected window, look at the
+values of `same-window-buffer-names' and `same-window-regexps'.
+Those variables take precedence over this one. */);
Vspecial_display_buffer_names = Qnil;
DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps,
- "*List of regexps saying which buffers should have their own special frames.\n\
-If a buffer name matches one of these regexps, it gets its own frame.\n\
-Displaying a buffer whose name is in this list makes a special frame for it\n\
-using `special-display-function'.\n\
-\n\
-An element of the list can be a list instead of just a string.\n\
-There are two ways to use a list as an element:\n\
- (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)\n\
-In the first case, FRAME-PARAMETERS are used to create the frame.\n\
-In the latter case, FUNCTION is called with the buffer as first argument,\n\
-followed by OTHER-ARGS--it can display the buffer in any way it likes.\n\
-All this is done by the function found in `special-display-function'.\n\
-\n\
-If this variable appears \"not to work\", because you add a regexp to it\n\
-but the matching buffers still appear in the selected window, look at the\n\
-values of `same-window-buffer-names' and `same-window-regexps'.\n\
-Those variables take precedence over this one.");
+ 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'.
+
+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:
+ (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
+In the first case, FRAME-PARAMETERS are used to create the frame.
+In the latter case, FUNCTION is called with the buffer as first argument,
+followed by OTHER-ARGS--it can display the buffer in any way it likes.
+All this is done by the function found in `special-display-function'.
+
+If this variable appears \"not to work\", because you add a regexp to it
+but the matching buffers still appear in the selected window, look at the
+values of `same-window-buffer-names' and `same-window-regexps'.
+Those variables take precedence over this one. */);
Vspecial_display_regexps = Qnil;
DEFVAR_LISP ("special-display-function", &Vspecial_display_function,
- "Function to call to make a new frame for a special buffer.\n\
-It is called with two arguments, the buffer and optional buffer specific\n\
-data, and should return a window displaying that buffer.\n\
-The default value makes a separate frame for the buffer,\n\
-using `special-display-frame-alist' to specify the frame parameters.\n\
-\n\
-A buffer is special if its is listed in `special-display-buffer-names'\n\
-or matches a regexp in `special-display-regexps'.");
+ doc: /* Function to call to make a new frame for a special buffer.
+It is called with two arguments, the buffer and optional buffer specific
+data, and should return a window displaying that buffer.
+The default value makes a separate frame for the buffer,
+using `special-display-frame-alist' to specify the frame parameters.
+
+A buffer is special if its is listed in `special-display-buffer-names'
+or matches a regexp in `special-display-regexps'. */);
Vspecial_display_function = Qnil;
DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names,
- "*List of buffer names that should appear in the selected window.\n\
-Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
-switches to it in the selected window, rather than making it appear\n\
-in some other window.\n\
-\n\
-An element of the list can be a cons cell instead of just a string.\n\
-Then the car must be a string, which specifies the buffer name.\n\
-This is for compatibility with `special-display-buffer-names';\n\
-the cdr of the cons cell is ignored.\n\
-\n\
-See also `same-window-regexps'.");
+ doc: /* *List of buffer names that should appear in the selected window.
+Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
+switches to it in the selected window, rather than making it appear
+in some other window.
+
+An element of the list can be a cons cell instead of just a string.
+Then the car must be a string, which specifies the buffer name.
+This is for compatibility with `special-display-buffer-names';
+the cdr of the cons cell is ignored.
+
+See also `same-window-regexps'. */);
Vsame_window_buffer_names = Qnil;
DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps,
- "*List of regexps saying which buffers should appear in the selected window.\n\
-If a buffer name matches one of these regexps, then displaying it\n\
-using `display-buffer' or `pop-to-buffer' switches to it\n\
-in the selected window, rather than making it appear in some other window.\n\
-\n\
-An element of the list can be a cons cell instead of just a string.\n\
-Then the car must be a string, which specifies the buffer name.\n\
-This is for compatibility with `special-display-buffer-names';\n\
-the cdr of the cons cell is ignored.\n\
-\n\
-See also `same-window-buffer-names'.");
+ doc: /* *List of regexps saying which buffers should appear in the selected window.
+If a buffer name matches one of these regexps, then displaying it
+using `display-buffer' or `pop-to-buffer' switches to it
+in the selected window, rather than making it appear in some other window.
+
+An element of the list can be a cons cell instead of just a string.
+Then the car must be a string, which specifies the buffer name.
+This is for compatibility with `special-display-buffer-names';
+the cdr of the cons cell is ignored.
+
+See also `same-window-buffer-names'. */);
Vsame_window_regexps = Qnil;
DEFVAR_BOOL ("pop-up-windows", &pop_up_windows,
- "*Non-nil means display-buffer should make new windows.");
+ doc: /* *Non-nil means display-buffer should make new windows. */);
pop_up_windows = 1;
DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines,
- "*Number of lines of continuity when scrolling by screenfuls.");
+ doc: /* *Number of lines of continuity when scrolling by screenfuls. */);
next_screen_context_lines = 2;
DEFVAR_INT ("split-height-threshold", &split_height_threshold,
- "*display-buffer would prefer to split the largest window if this large.\n\
-If there is only one window, it is split regardless of this value.");
+ doc: /* *display-buffer would prefer to split the largest window if this large.
+If there is only one window, it is split regardless of this value. */);
split_height_threshold = 500;
DEFVAR_INT ("window-min-height", &window_min_height,
- "*Delete any window less than this tall (including its mode line).");
+ doc: /* *Delete any window less than this tall (including its mode line). */);
window_min_height = 4;
DEFVAR_INT ("window-min-width", &window_min_width,
- "*Delete any window less than this wide.");
+ doc: /* *Delete any window less than this wide. */);
window_min_width = 10;
DEFVAR_LISP ("scroll-preserve-screen-position",
&Vscroll_preserve_screen_position,
- "*Nonzero means scroll commands move point to keep its screen line unchanged.");
+ doc: /* *Non-nil means scroll commands move point to keep its screen line unchanged. */);
Vscroll_preserve_screen_position = Qnil;
DEFVAR_LISP ("window-configuration-change-hook",
&Vwindow_configuration_change_hook,
- "Functions to call when window configuration changes.\n\
-The selected frame is the one whose configuration has changed.");
+ doc: /* Functions to call when window configuration changes.
+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.
+Emacs won't change the size of any window displaying that buffer,
+unless you explicitly change the size, or Emacs has no other choice.
+This variable automatically becomes buffer-local when set. */);
+ Fmake_variable_buffer_local (Qwindow_size_fixed);
+ window_size_fixed = 0;
+
defsubr (&Sselected_window);
defsubr (&Sminibuffer_window);
defsubr (&Swindow_minibuffer_p);
defsubr (&Sscroll_right);
defsubr (&Sother_window_for_scrolling);
defsubr (&Sscroll_other_window);
+ defsubr (&Sminibuffer_selected_window);
defsubr (&Srecenter);
defsubr (&Swindow_text_height);
defsubr (&Smove_to_window_line);
HCoop / bpt / emacs.git / blobdiff