#include <stdio.h>
#include "lisp.h"
-#include "character.h"
#include "buffer.h"
#include "keyboard.h"
#include "keymap.h"
-#include "menu.h"
#include "frame.h"
#include "window.h"
#include "commands.h"
#include "disptab.h"
#include "dispextern.h"
#include "blockinput.h"
-#include "intervals.h"
#include "termhooks.h" /* For FRAME_TERMINAL. */
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#include "msdos.h"
#endif
-static int count_windows (struct window *);
-static int get_leaf_windows (struct window *, struct window **, int);
+static ptrdiff_t count_windows (struct window *);
+static ptrdiff_t get_leaf_windows (struct window *, struct window **,
+ ptrdiff_t);
static void window_scroll_pixel_based (Lisp_Object, int, bool, bool);
static void window_scroll_line_based (Lisp_Object, int, bool, bool);
static void foreach_window (struct frame *,
Lisp_Object minibuf_selected_window;
/* Incremented for each window created. */
-static int sequence_number;
+static EMACS_INT sequence_number;
/* Used by the function window_scroll_pixel_based. */
static int window_scroll_pixel_based_preserve_x;
w->horizontal = horflag;
}
+static void
+wset_update_mode_line (struct window *w)
+{
+ /* If this window is the selected window on its frame, set the
+ global variable update_mode_lines, so that x_consider_frame_title
+ will consider this frame's title for redisplay. */
+ Lisp_Object fselected_window = XFRAME (WINDOW_FRAME (w))->selected_window;
+
+ if (WINDOWP (fselected_window) && XWINDOW (fselected_window) == w)
+ update_mode_lines = 42;
+ else
+ w->update_mode_line = true;
+}
+
/* True if leaf window W doesn't reflect the actual state
of displayed buffer due to its text or overlays change. */
return selected_window;
}
-int window_select_count;
+EMACS_INT window_select_count;
/* If select_window is called with inhibit_point_swap true it will
not store point of the old selected window's buffer back into that
WINDOW must be a valid window used in horizontal or vertical combination.
If the return value is nil, child windows of WINDOW can be recombined with
WINDOW's siblings. A return value of t means that child windows of
-WINDOW are never \(re-)combined with WINDOW's siblings. */)
+WINDOW are never (re-)combined with WINDOW's siblings. */)
(Lisp_Object window)
{
struct window *w;
WINDOW must be a valid window used in horizontal or vertical combination.
If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
siblings. LIMIT t means that child windows of WINDOW are never
-\(re-)combined with WINDOW's siblings. Other values are reserved for
+(re-)combined with WINDOW's siblings. Other values are reserved for
future use. */)
(Lisp_Object window, Lisp_Object limit)
{
return value;
}
-DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
- doc: /* Return a list of the edge coordinates of WINDOW.
-WINDOW must be a valid window and defaults to the selected one.
-
-The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
-count by lines, and LEFT and RIGHT count by columns, all relative to 0,
-0 at top left corner of frame.
-
-RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
-is one more than the bottommost row occupied by WINDOW. The edges
-include the space used by WINDOW's scroll bar, display margins, fringes,
-header line, and/or mode line. For the edges of just the text area, use
-`window-inside-edges'. */)
- (Lisp_Object window)
-{
- register struct window *w = decode_valid_window (window);
-
- return list4i (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
- WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
-}
-
-DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
- doc: /* Return a list of the edge pixel coordinates of WINDOW.
-WINDOW must be a valid window and defaults to the selected one.
-
-The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
-0, 0 at the top left corner of the frame.
-
-RIGHT is one more than the rightmost x position occupied by WINDOW.
-BOTTOM is one more than the bottommost y position occupied by WINDOW.
-The pixel edges include the space used by WINDOW's scroll bar, display
-margins, fringes, header line, and/or mode line. For the pixel edges
-of just the text area, use `window-inside-pixel-edges'. */)
- (Lisp_Object window)
-{
- register struct window *w = decode_valid_window (window);
-
- return list4i (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
- WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
-}
-
-static void
-calc_absolute_offset (struct window *w, int *add_x, int *add_y)
-{
- struct frame *f = XFRAME (w->frame);
- *add_y = f->top_pos;
-#ifdef FRAME_MENUBAR_HEIGHT
- *add_y += FRAME_MENUBAR_HEIGHT (f);
-#endif
-#ifdef FRAME_TOOLBAR_TOP_HEIGHT
- *add_y += FRAME_TOOLBAR_TOP_HEIGHT (f);
-#elif defined (FRAME_TOOLBAR_HEIGHT)
- *add_y += FRAME_TOOLBAR_HEIGHT (f);
-#endif
-#ifdef FRAME_NS_TITLEBAR_HEIGHT
- *add_y += FRAME_NS_TITLEBAR_HEIGHT (f);
-#endif
- *add_x = f->left_pos;
-#ifdef FRAME_TOOLBAR_LEFT_WIDTH
- *add_x += FRAME_TOOLBAR_LEFT_WIDTH (f);
-#endif
-}
-
-DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges,
- Swindow_absolute_pixel_edges, 0, 1, 0,
- doc: /* Return a list of the edge pixel coordinates of WINDOW.
-WINDOW must be a valid window and defaults to the selected one.
-
-The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
-0, 0 at the top left corner of the display.
-
-RIGHT is one more than the rightmost x position occupied by WINDOW.
-BOTTOM is one more than the bottommost y position occupied by WINDOW.
-The pixel edges include the space used by WINDOW's scroll bar, display
-margins, fringes, header line, and/or mode line. For the pixel edges
-of just the text area, use `window-inside-absolute-pixel-edges'. */)
- (Lisp_Object window)
-{
- register struct window *w = decode_valid_window (window);
- int add_x, add_y;
-
- calc_absolute_offset (w, &add_x, &add_y);
-
- return list4i (WINDOW_LEFT_EDGE_X (w) + add_x,
- WINDOW_TOP_EDGE_Y (w) + add_y,
- WINDOW_RIGHT_EDGE_X (w) + add_x,
- WINDOW_BOTTOM_EDGE_Y (w) + add_y);
-}
-
-DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
- doc: /* Return a list of the edge coordinates of WINDOW.
-WINDOW must be a live window and defaults to the selected one.
-
-The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
-count by lines, and LEFT and RIGHT count by columns, all relative to 0,
-0 at top left corner of frame.
-
-RIGHT is one more than the rightmost column of WINDOW's text area.
-BOTTOM is one more than the bottommost row of WINDOW's text area. The
-inside edges do not include the space used by the WINDOW's scroll bar,
-display margins, fringes, header line, and/or mode line. */)
- (Lisp_Object window)
-{
- register struct window *w = decode_live_window (window);
-
- return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w)
- + WINDOW_LEFT_MARGIN_COLS (w)
- + ((WINDOW_LEFT_FRINGE_WIDTH (w)
- + WINDOW_FRAME_COLUMN_WIDTH (w) - 1)
- / WINDOW_FRAME_COLUMN_WIDTH (w))),
- (WINDOW_TOP_EDGE_LINE (w)
- + WINDOW_HEADER_LINE_LINES (w)),
- (WINDOW_BOX_RIGHT_EDGE_COL (w)
- - WINDOW_RIGHT_MARGIN_COLS (w)
- - ((WINDOW_RIGHT_FRINGE_WIDTH (w)
- + WINDOW_FRAME_COLUMN_WIDTH (w) - 1)
- / WINDOW_FRAME_COLUMN_WIDTH (w))),
- (WINDOW_BOTTOM_EDGE_LINE (w)
- - WINDOW_MODE_LINE_LINES (w)));
-}
-
-DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
- doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
-WINDOW must be a live window and defaults to the selected one.
-
-The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
-(0,0) at the top left corner of the frame's window area.
-
-RIGHT is one more than the rightmost x position of WINDOW's text area.
-BOTTOM is one more than the bottommost y position of WINDOW's text area.
-The inside edges do not include the space used by WINDOW's scroll bar,
-display margins, fringes, header line, and/or mode line. */)
- (Lisp_Object window)
-{
- register struct window *w = decode_live_window (window);
-
- return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
- + WINDOW_LEFT_MARGIN_WIDTH (w)
- + WINDOW_LEFT_FRINGE_WIDTH (w)),
- (WINDOW_TOP_EDGE_Y (w)
- + WINDOW_HEADER_LINE_HEIGHT (w)),
- (WINDOW_BOX_RIGHT_EDGE_X (w)
- - WINDOW_RIGHT_MARGIN_WIDTH (w)
- - WINDOW_RIGHT_FRINGE_WIDTH (w)),
- (WINDOW_BOTTOM_EDGE_Y (w)
- - WINDOW_MODE_LINE_HEIGHT (w)));
-}
-
-DEFUN ("window-inside-absolute-pixel-edges",
- Fwindow_inside_absolute_pixel_edges,
- Swindow_inside_absolute_pixel_edges, 0, 1, 0,
- doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
-WINDOW must be a live window and defaults to the selected one.
-
-The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
-(0,0) at the top left corner of the frame's window area.
-
-RIGHT is one more than the rightmost x position of WINDOW's text area.
-BOTTOM is one more than the bottommost y position of WINDOW's text area.
-The inside edges do not include the space used by WINDOW's scroll bar,
-display margins, fringes, header line, and/or mode line. */)
- (Lisp_Object window)
-{
- register struct window *w = decode_live_window (window);
- int add_x, add_y;
-
- calc_absolute_offset (w, &add_x, &add_y);
-
- return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
- + WINDOW_LEFT_MARGIN_WIDTH (w)
- + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
- (WINDOW_TOP_EDGE_Y (w)
- + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
- (WINDOW_BOX_RIGHT_EDGE_X (w)
- - WINDOW_RIGHT_MARGIN_WIDTH (w)
- - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
- (WINDOW_BOTTOM_EDGE_Y (w)
- - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
-}
-
/* Test if the character at column X, row Y is within window W.
If it is not, return ON_NOTHING;
if it is on the window's vertical divider, return
+ window_box_width (w, RIGHT_MARGIN_AREA)
+ ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
? WINDOW_RIGHT_FRINGE_WIDTH (w) : 0));
- }
- /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
- return 0;
+ case ON_NOTHING:
+ case ON_VERTICAL_BORDER:
+ case ON_VERTICAL_SCROLL_BAR:
+ case ON_HORIZONTAL_SCROLL_BAR:
+ case ON_RIGHT_DIVIDER:
+ case ON_BOTTOM_DIVIDER:
+ return 0;
+
+ default:
+ emacs_abort ();
+ }
}
WINDOW must be a live window and defaults to the selected one.
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
+(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.
|| b->clip_changed
|| b->prevent_redisplay_optimizations_p
|| window_outdated (w))
- && !noninteractive)
+ /* Don't call display routines if we didn't yet create any real
+ frames, because the glyph matrices are not yet allocated in
+ that case. This could happen in some code that runs in the
+ daemon during initialization (e.g., see bug#20565). */
+ && !(noninteractive || FRAME_INITIAL_P (WINDOW_XFRAME (w))))
{
struct text_pos startp;
struct it it;
w->start_at_line_beg = false;
if (NILP (noforce))
w->force_start = true;
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Bug#15957. */
w->window_end_valid = false;
wset_redisplay (w);
character is only partially visible, nil is returned, unless the
optional argument PARTIALLY is non-nil. If POS is only out of view
because of horizontal scrolling, return non-nil. If POS is t, it
-specifies the position of the last visible glyph in WINDOW. POS
-defaults to point in WINDOW; WINDOW defaults to the selected window.
+specifies either the first position displayed on the last visible
+screen line in WINDOW, or the end-of-buffer position, whichever comes
+first. POS defaults to point in WINDOW; WINDOW defaults to the
+selected window.
If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
the return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
off-window at the top and bottom of the screen line ("row") containing
POS, ROWH is the visible height of that row, and VPOS is the row number
-\(zero-based). */)
+(zero-based). */)
(Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
{
struct window *w;
Lisp_Object window, windows, best_window, frame_arg;
bool frame_best_window_flag = false;
struct frame *f;
- struct gcpro gcpro1;
/* If we're only looping through windows on a particular frame,
frame points to that frame. If we're looping through windows
window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
windows = window_list_1 (window, mini ? Qt : Qnil, frame_arg);
- GCPRO1 (windows);
best_window = Qnil;
for (; CONSP (windows); windows = XCDR (windows))
{
if (EQ (window, selected_window))
/* Preferably return the selected window. */
- RETURN_UNGCPRO (window);
+ return window;
else if (EQ (XWINDOW (window)->frame, selected_frame)
&& !frame_best_window_flag)
/* Prefer windows on the current frame (but don't
}
}
- UNGCPRO;
return best_window;
}
/* Maybe we could move this into the `if' but it's not obviously safe and
I doubt it's worth the trouble. */
wset_redisplay (w);
- w->update_mode_line = true;
+
+ wset_update_mode_line (w);
/* We must select BUFFER to run the window-scroll-functions and to look up
the buffer-local value of Vwindow_point_insertion_type. */
/* old_size is the old size of the frame's root window. */
int old_size = horflag ? r->total_cols : r->total_lines;
int old_pixel_size = horflag ? r->pixel_width : r->pixel_height;
- int old_pixel_top = r->pixel_top;
/* new_size is the new size of the frame's root window. */
int new_size, new_pixel_size;
int unit = horflag ? FRAME_COLUMN_WIDTH (f) : FRAME_LINE_HEIGHT (f);
new_pixel_size = new_size * unit;
}
- r->top_line = FRAME_TOP_MARGIN (f);
- r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
-
if (new_pixel_size == old_pixel_size
- && r->pixel_top == old_pixel_top)
+ && (horflag || r->pixel_top == FRAME_TOP_MARGIN_HEIGHT (f)))
;
else if (WINDOW_LEAF_P (r))
/* For a leaf root window just set the size. */
}
else
{
+ r->top_line = FRAME_TOP_MARGIN (f);
+ r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
+
r->total_lines = new_size;
r->pixel_height = new_pixel_size;
}
{
Lisp_Object delta;
+ if (!horflag)
+ {
+ r->top_line = FRAME_TOP_MARGIN (f);
+ r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
+ }
+
if (pixelwise)
XSETINT (delta, new_pixel_size - old_pixel_size);
else
DEFUN ("split-window-internal", Fsplit_window_internal, Ssplit_window_internal, 4, 4, 0,
doc: /* Split window OLD.
Second argument PIXEL-SIZE specifies the number of pixels of the
-new window. In any case TOTAL-SIZE must be a positive integer.
+new window. It must be a positive integer.
Third argument SIDE nil (or `below') specifies that the new window shall
be located below WINDOW. SIDE `above' means the new window shall be
f = XFRAME (frame);
CHECK_NUMBER (pixel_size);
- int total_size
+ EMACS_INT total_size
= XINT (pixel_size) / (horflag
? FRAME_COLUMN_WIDTH (f)
: FRAME_LINE_HEIGHT (f));
/* Iso-coordinates and sizes are assigned by window_resize_apply,
get them ready here. */
wset_new_pixel (n, pixel_size);
- int sum = 0;
+ EMACS_INT sum = 0;
c = XWINDOW (p->contents);
while (c)
{
set_marker_restricted (w->start, make_number (spos),
w->contents);
w->start_at_line_beg = true;
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Set force_start so that redisplay_window will run the
window-scroll-functions. */
w->force_start = true;
IT_BYTEPOS (it));
bytepos = marker_byte_position (w->start);
w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Set force_start so that redisplay_window will run the
window-scroll-functions. */
w->force_start = true;
set_marker_restricted_both (w->start, w->contents, pos, pos_byte);
w->start_at_line_beg = !NILP (bolp);
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Set force_start so that redisplay_window will run
the window-scroll-functions. */
w->force_start = true;
{
Lisp_Object window;
Lisp_Object dead_windows = Qnil;
- register Lisp_Object tem, par, pers;
- register struct window *w;
- register struct saved_window *p;
+ Lisp_Object tem, par, pers;
+ struct window *w;
+ struct saved_window *p;
struct window *root_window;
struct window **leaf_windows;
- int n_leaf_windows;
- ptrdiff_t k;
- int i, n;
+ ptrdiff_t i, k, n_leaf_windows;
/* Don't do this within the main loop below: This may call Lisp
code and is thus potentially unsafe while input is blocked. */
really like to do is to free only those matrices not reused
below. */
root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
- int nwindows = count_windows (root_window);
+ ptrdiff_t nwindows = count_windows (root_window);
SAFE_NALLOCA (leaf_windows, 1, nwindows);
n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
Fredirect_frame_focus (frame, data->focus_frame);
/* Now, free glyph matrices in windows that were not reused. */
- for (i = n = 0; i < n_leaf_windows; ++i)
- {
- if (NILP (leaf_windows[i]->contents))
- free_window_matrices (leaf_windows[i]);
- else if (EQ (leaf_windows[i]->contents, new_current_buffer))
- ++n;
- }
+ for (i = 0; i < n_leaf_windows; i++)
+ if (NILP (leaf_windows[i]->contents))
+ free_window_matrices (leaf_windows[i]);
/* Allow x_set_window_size again and apply frame size changes if
needed. */
Vwindow_list = Qnil;
}
\f
-static int
-count_windows (register struct window *window)
+static ptrdiff_t
+count_windows (struct window *window)
{
- register int count = 1;
+ ptrdiff_t count = 1;
if (!NILP (window->next))
count += count_windows (XWINDOW (window->next));
if (WINDOWP (window->contents))
/* Fill vector FLAT with leaf windows under W, starting at index I.
Value is last index + 1. */
-static int
-get_leaf_windows (struct window *w, struct window **flat, int i)
+static ptrdiff_t
+get_leaf_windows (struct window *w, struct window **flat, ptrdiff_t i)
{
while (w)
{
}
-static int
-save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
+static ptrdiff_t
+save_window_save (Lisp_Object window, struct Lisp_Vector *vector, ptrdiff_t i)
{
- register struct saved_window *p;
- register struct window *w;
- register Lisp_Object tem, pers, par;
+ struct saved_window *p;
+ struct window *w;
+ Lisp_Object tem, pers, par;
for (; !NILP (window); window = w->next)
{
saved by this function. */)
(Lisp_Object frame)
{
- register Lisp_Object tem;
- register int n_windows;
- register struct save_window_data *data;
- register int i;
+ Lisp_Object tem;
+ ptrdiff_t i, n_windows;
+ struct save_window_data *data;
struct frame *f = decode_live_frame (frame);
n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
eassert (w);
clear_glyph_matrix (w->current_matrix);
w->window_end_valid = false;
- windows_or_buffers_changed = 30;
wset_redisplay (w);
adjust_frame_glyphs (XFRAME (WINDOW_FRAME (w)));
}
Marginal Areas
***********************************************************************/
+static int
+extract_dimension (Lisp_Object dimension)
+{
+ if (NILP (dimension))
+ return -1;
+ CHECK_RANGED_INTEGER (dimension, 0, INT_MAX);
+ return XINT (dimension);
+}
+
static struct window *
set_window_margins (struct window *w, Lisp_Object left_width,
Lisp_Object right_width)
{
- int left, right;
int unit = WINDOW_FRAME_COLUMN_WIDTH (w);
-
- left = (NILP (left_width) ? 0
- : (CHECK_NATNUM (left_width), XINT (left_width)));
- right = (NILP (right_width) ? 0
- : (CHECK_NATNUM (right_width), XINT (right_width)));
+ int left = NILP (left_width) ? 0 : extract_dimension (left_width);
+ int right = NILP (right_width) ? 0 : extract_dimension (right_width);
if (w->left_margin_cols != left || w->right_margin_cols != right)
{
set_window_fringes (struct window *w, Lisp_Object left_width,
Lisp_Object right_width, Lisp_Object outside_margins)
{
- int left, right;
bool outside = !NILP (outside_margins);
-
- left = (NILP (left_width) ? -1
- : (CHECK_NATNUM (left_width), XINT (left_width)));
- right = (NILP (right_width) ? -1
- : (CHECK_NATNUM (right_width), XINT (right_width)));
+ int left = extract_dimension (left_width);
+ int right = extract_dimension (right_width);
/* Do nothing on a tty or if nothing to actually change. */
if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
Lisp_Object vertical_type, Lisp_Object height,
Lisp_Object horizontal_type)
{
- int iwidth = (NILP (width) ? -1 : (CHECK_NATNUM (width), XINT (width)));
+ int iwidth = extract_dimension (width);
bool changed = false;
if (iwidth == 0)
#if USE_HORIZONTAL_SCROLL_BARS
{
- int iheight = (NILP (height) ? -1 : (CHECK_NATNUM (height), XINT (height)));
+ int iheight = extract_dimension (height);
if (MINI_WINDOW_P (w) || iheight == 0)
horizontal_type = Qnil;
DEFSYM (Qwindow_size, "window-size");
DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
DEFSYM (Qabove, "above");
- DEFSYM (Qbelow, "below");
DEFSYM (Qclone_of, "clone-of");
DEFSYM (Qfloor, "floor");
DEFSYM (Qceiling, "ceiling");
defsubr (&Sset_window_hscroll);
defsubr (&Swindow_redisplay_end_trigger);
defsubr (&Sset_window_redisplay_end_trigger);
- defsubr (&Swindow_edges);
- defsubr (&Swindow_pixel_edges);
- defsubr (&Swindow_absolute_pixel_edges);
defsubr (&Swindow_mode_line_height);
defsubr (&Swindow_header_line_height);
defsubr (&Swindow_right_divider_width);
defsubr (&Swindow_bottom_divider_width);
defsubr (&Swindow_scroll_bar_width);
defsubr (&Swindow_scroll_bar_height);
- defsubr (&Swindow_inside_edges);
- defsubr (&Swindow_inside_pixel_edges);
- defsubr (&Swindow_inside_absolute_pixel_edges);
defsubr (&Scoordinates_in_window_p);
defsubr (&Swindow_at);
defsubr (&Swindow_point);