* window.h (WGET, WSET): New macros similar to AREF and ASET.
* alloc.c, buffer.c, composite.c, dispextern.h, dispnew.c, editfns.c:
* fileio.c, font.c, fontset.c, frame.c, frame.h, fringe.c, indent.c:
* insdel.c, keyboard.c, keymap.c, lisp.h, minibuf.c, msdos.c, nsfns.m:
* nsmenu.m, nsterm.m, print.c, textprop.c, w32fns.c, w32menu.c:
* w32term.c, window.c, xdisp.c, xfaces.c, xfns.c, xmenu.c, xterm.c:
Adjust users.
+2012-08-06 Dmitry Antipov <dmantipov@yandex.ru>
+
+ Separate read and write access to Lisp_Object slots of struct window.
+ * window.h (WGET, WSET): New macros similar to AREF and ASET.
+ * alloc.c, buffer.c, composite.c, dispextern.h, dispnew.c, editfns.c:
+ * fileio.c, font.c, fontset.c, frame.c, frame.h, fringe.c, indent.c:
+ * insdel.c, keyboard.c, keymap.c, lisp.h, minibuf.c, msdos.c, nsfns.m:
+ * nsmenu.m, nsterm.m, print.c, textprop.c, w32fns.c, w32menu.c:
+ * w32term.c, window.c, xdisp.c, xfaces.c, xfns.c, xmenu.c, xterm.c:
+ Adjust users.
+
2012-08-06 Dmitry Antipov <dmantipov@yandex.ru>
Fix Windows build errors introduced after converting to FGET and FSET.
/* Mark glyphs for leaf windows. Marking window
matrices is sufficient because frame matrices
use the same glyph memory. */
- if (NILP (WVAR (w, hchild)) && NILP (WVAR (w, vchild))
+ if (NILP (WGET (w, hchild)) && NILP (WGET (w, vchild))
&& w->current_matrix)
{
mark_glyph_matrix (w->current_matrix);
since anything can happen within do_yes_or_no_p. */
/* Don't kill the minibuffer now current. */
- if (EQ (buffer, WVAR (XWINDOW (minibuf_window), buffer)))
+ if (EQ (buffer, WGET (XWINDOW (minibuf_window), buffer)))
return Qnil;
/* When we kill an ordinary buffer which shares it's buffer text
/* If the buffer now current is shown in the minibuffer and our buffer
is the sole other buffer give up. */
XSETBUFFER (tem, current_buffer);
- if (EQ (tem, WVAR (XWINDOW (minibuf_window), buffer))
+ if (EQ (tem, WGET (XWINDOW (minibuf_window), buffer))
&& EQ (buffer, Fother_buffer (buffer, Qnil, Qnil)))
return Qnil;
while (NILP (Fmemq (w, ws)))
{
ws = Fcons (w, ws);
- if (MARKERP (WVAR (XWINDOW (w), pointm))
- && (EQ (WVAR (XWINDOW (w), buffer), buf1)
- || EQ (WVAR (XWINDOW (w), buffer), buf2)))
- Fset_marker (WVAR (XWINDOW (w), pointm),
+ if (MARKERP (WGET (XWINDOW (w), pointm))
+ && (EQ (WGET (XWINDOW (w), buffer), buf1)
+ || EQ (WGET (XWINDOW (w), buffer), buf2)))
+ Fset_marker (WGET (XWINDOW (w), pointm),
make_number
- (BUF_BEGV (XBUFFER (WVAR (XWINDOW (w), buffer)))),
- WVAR (XWINDOW (w), buffer));
+ (BUF_BEGV (XBUFFER (WGET (XWINDOW (w), buffer)))),
+ WGET (XWINDOW (w), buffer));
w = Fnext_window (w, Qt, Qt);
}
}
/* If this is a buffer not in the selected window,
we must do other windows. */
- if (buf != XBUFFER (WVAR (XWINDOW (selected_window), buffer)))
+ if (buf != XBUFFER (WGET (XWINDOW (selected_window), buffer)))
windows_or_buffers_changed = 1;
/* If multiple windows show this buffer, we must do other windows. */
else if (buffer_shared > 1)
autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t limit, struct window *win, struct face *face, Lisp_Object string)
{
ptrdiff_t count = SPECPDL_INDEX ();
- FRAME_PTR f = XFRAME (WVAR (win, frame));
+ FRAME_PTR f = XFRAME (WGET (win, frame));
Lisp_Object pos = make_number (charpos);
ptrdiff_t to;
ptrdiff_t pt = PT, pt_byte = PT_BYTE;
}
else
#endif /* not HAVE_WINDOW_SYSTEM */
- font_object = WVAR (win, frame);
+ font_object = WGET (win, frame);
lgstring = Fcomposition_get_gstring (pos, make_number (to), font_object,
string);
if (NILP (LGSTRING_ID (lgstring)))
? current_mode_line_height \
: (MATRIX_MODE_LINE_HEIGHT ((W)->current_matrix) \
? MATRIX_MODE_LINE_HEIGHT ((W)->current_matrix) \
- : estimate_mode_line_height (XFRAME (WVAR (W, frame)), \
+ : estimate_mode_line_height (XFRAME (WGET (W, frame)), \
CURRENT_MODE_LINE_FACE_ID (W))))
/* Return the current height of the header line of window W. If not
? current_header_line_height \
: (MATRIX_HEADER_LINE_HEIGHT ((W)->current_matrix) \
? MATRIX_HEADER_LINE_HEIGHT ((W)->current_matrix) \
- : estimate_mode_line_height (XFRAME (WVAR (W, frame)),\
+ : estimate_mode_line_height (XFRAME (WGET (W, frame)),\
HEADER_LINE_FACE_ID)))
/* Return the height of the desired mode line of window W. */
(!MINI_WINDOW_P ((W)) \
&& !(W)->pseudo_window_p \
&& FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W)))) \
- && BUFFERP (WVAR (W, buffer)) \
- && !NILP (BVAR (XBUFFER (WVAR (W, buffer)), mode_line_format)) \
+ && BUFFERP (WGET (W, buffer)) \
+ && !NILP (BVAR (XBUFFER (WGET (W, buffer)), mode_line_format)) \
&& WINDOW_TOTAL_LINES (W) > 1)
/* Value is non-zero if window W wants a header line. */
(!MINI_WINDOW_P ((W)) \
&& !(W)->pseudo_window_p \
&& FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W)))) \
- && BUFFERP (WVAR (W, buffer)) \
- && !NILP (BVAR (XBUFFER (WVAR (W, buffer)), header_line_format)) \
+ && BUFFERP (WGET (W, buffer)) \
+ && !NILP (BVAR (XBUFFER (WGET (W, buffer)), header_line_format)) \
&& WINDOW_TOTAL_LINES (W) > 1 \
- + !NILP (BVAR (XBUFFER (WVAR (W, buffer)), mode_line_format)))
+ + !NILP (BVAR (XBUFFER (WGET (W, buffer)), mode_line_format)))
/* Return proper value to be used as baseline offset of font that has
"%"pMu": window %p (`%s')%s\n%s",
history_tick++,
w,
- ((BUFFERP (WVAR (w, buffer))
- && STRINGP (BVAR (XBUFFER (WVAR (w, buffer)), name)))
- ? SSDATA (BVAR (XBUFFER (WVAR (w, buffer)), name))
+ ((BUFFERP (WGET (w, buffer))
+ && STRINGP (BVAR (XBUFFER (WGET (w, buffer)), name)))
+ ? SSDATA (BVAR (XBUFFER (WGET (w, buffer)), name))
: "???"),
paused_p ? " ***paused***" : "",
msg);
if (NUMBERP (margin))
{
- int width = XFASTINT (WVAR (w, total_cols));
+ int width = XFASTINT (WGET (w, total_cols));
double d = max (0, XFLOATINT (margin));
d = min (width / 2 - 1, d);
n = (int) ((double) total_glyphs / width * d);
the matrix means preventing redisplay. */
if (matrix->pool == NULL)
{
- left = margin_glyphs_to_reserve (w, dim.width, WVAR (w, left_margin_cols));
- right = margin_glyphs_to_reserve (w, dim.width, WVAR (w, right_margin_cols));
+ left = margin_glyphs_to_reserve (w, dim.width, WGET (w, left_margin_cols));
+ right = margin_glyphs_to_reserve (w, dim.width, WGET (w, right_margin_cols));
eassert (left >= 0 && right >= 0);
marginal_areas_changed_p = (left != matrix->left_margin_glyphs
|| right != matrix->right_margin_glyphs);
if (w)
{
left = margin_glyphs_to_reserve (w, dim.width,
- WVAR (w, left_margin_cols));
+ WGET (w, left_margin_cols));
right = margin_glyphs_to_reserve (w, dim.width,
- WVAR (w, right_margin_cols));
+ WGET (w, right_margin_cols));
}
else
left = right = 0;
/* Window end is invalid, if inside of the rows that
are invalidated below. */
- if (INTEGERP (WVAR (w, window_end_vpos))
- && XFASTINT (WVAR (w, window_end_vpos)) >= i)
- WVAR (w, window_end_valid) = Qnil;
+ if (INTEGERP (WGET (w, window_end_vpos))
+ && XFASTINT (WGET (w, window_end_vpos)) >= i)
+ WSET (w, window_end_valid, Qnil);
while (i < matrix->nrows)
matrix->rows[i++].enabled_p = 0;
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
+ if (!NILP (WGET (w, hchild)))
{
- eassert (WINDOWP (WVAR (w, hchild)));
- clear_window_matrices (XWINDOW (WVAR (w, hchild)), desired_p);
+ eassert (WINDOWP (WGET (w, hchild)));
+ clear_window_matrices (XWINDOW (WGET (w, hchild)), desired_p);
}
- else if (!NILP (WVAR (w, vchild)))
+ else if (!NILP (WGET (w, vchild)))
{
- eassert (WINDOWP (WVAR (w, vchild)));
- clear_window_matrices (XWINDOW (WVAR (w, vchild)), desired_p);
+ eassert (WINDOWP (WGET (w, vchild)));
+ clear_window_matrices (XWINDOW (WGET (w, vchild)), desired_p);
}
else
{
else
{
clear_glyph_matrix (w->current_matrix);
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
}
}
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
clear_glyph_row (row);
row->y = y;
row->ascent = row->phys_ascent = 0;
- row->height = row->phys_height = FRAME_LINE_HEIGHT (XFRAME (WVAR (w, frame)));
+ row->height = row->phys_height = FRAME_LINE_HEIGHT (XFRAME (WGET (w, frame)));
row->visible_height = row->height;
if (row->y < min_y)
struct glyph_row *row = matrix->rows;
struct glyph_row *last_text_row = NULL;
struct buffer *saved = current_buffer;
- struct buffer *buffer = XBUFFER (WVAR (w, buffer));
+ struct buffer *buffer = XBUFFER (WGET (w, buffer));
int c;
/* This can sometimes happen for a fresh window. */
points to the mini-buffer window, if any, which is arranged
vertically below other windows. */
in_horz_combination_p
- = (!NILP (WVAR (XWINDOW (window), parent))
- && !NILP (WVAR (XWINDOW (WVAR (XWINDOW (window), parent)), hchild)));
+ = (!NILP (WGET (XWINDOW (window), parent))
+ && !NILP (WGET (XWINDOW (WGET (XWINDOW (window), parent)), hchild)));
/* For WINDOW and all windows on the same level. */
do
/* Get the dimension of the window sub-matrix for W, depending
on whether this is a combination or a leaf window. */
- if (!NILP (WVAR (w, hchild)))
- dim = allocate_matrices_for_frame_redisplay (WVAR (w, hchild), x, y,
+ if (!NILP (WGET (w, hchild)))
+ dim = allocate_matrices_for_frame_redisplay (WGET (w, hchild), x, y,
dim_only_p,
window_change_flags);
- else if (!NILP (WVAR (w, vchild)))
- dim = allocate_matrices_for_frame_redisplay (WVAR (w, vchild), x, y,
+ else if (!NILP (WGET (w, vchild)))
+ dim = allocate_matrices_for_frame_redisplay (WGET (w, vchild), x, y,
dim_only_p,
window_change_flags);
else
|| dim.width != w->desired_matrix->matrix_w
|| dim.height != w->desired_matrix->matrix_h
|| (margin_glyphs_to_reserve (w, dim.width,
- WVAR (w, left_margin_cols))
+ WGET (w, left_margin_cols))
!= w->desired_matrix->left_margin_glyphs)
|| (margin_glyphs_to_reserve (w, dim.width,
- WVAR (w, right_margin_cols))
+ WGET (w, right_margin_cols))
!= w->desired_matrix->right_margin_glyphs))
*window_change_flags |= CHANGED_LEAF_MATRIX;
hmax = max (hmax, dim.height);
/* Next window on same level. */
- window = WVAR (w, next);
+ window = WGET (w, next);
}
while (!NILP (window));
required_matrix_height (struct window *w)
{
#ifdef HAVE_WINDOW_SYSTEM
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
if (FRAME_WINDOW_P (f))
{
required_matrix_width (struct window *w)
{
#ifdef HAVE_WINDOW_SYSTEM
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
if (FRAME_WINDOW_P (f))
{
int ch_width = FRAME_SMALLEST_CHAR_WIDTH (f);
}
#endif /* HAVE_WINDOW_SYSTEM */
- return XINT (WVAR (w, total_cols));
+ return XINT (WGET (w, total_cols));
}
{
while (w)
{
- if (!NILP (WVAR (w, vchild)))
- allocate_matrices_for_window_redisplay (XWINDOW (WVAR (w, vchild)));
- else if (!NILP (WVAR (w, hchild)))
- allocate_matrices_for_window_redisplay (XWINDOW (WVAR (w, hchild)));
+ if (!NILP (WGET (w, vchild)))
+ allocate_matrices_for_window_redisplay (XWINDOW (WGET (w, vchild)));
+ else if (!NILP (WGET (w, hchild)))
+ allocate_matrices_for_window_redisplay (XWINDOW (WGET (w, hchild)));
else
{
/* W is a leaf window. */
adjust_glyph_matrix (w, w->current_matrix, 0, 0, dim);
}
- w = NILP (WVAR (w, next)) ? NULL : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? NULL : XWINDOW (WGET (w, next));
}
}
{
struct frame *sf = SELECTED_FRAME ();
struct window *root = XWINDOW (FGET (sf, root_window));
- struct window *mini = XWINDOW (WVAR (root, next));
+ struct window *mini = XWINDOW (WGET (root, next));
int frame_lines = FRAME_LINES (sf);
int frame_cols = FRAME_COLS (sf);
int top_margin = FRAME_TOP_MARGIN (sf);
/* Do it for the root window. */
- XSETFASTINT (WVAR (root, top_line), top_margin);
- XSETFASTINT (WVAR (root, total_lines), frame_lines - 1 - top_margin);
- XSETFASTINT (WVAR (root, total_cols), frame_cols);
+ WSET (root, top_line, make_number (top_margin));
+ WSET (root, total_lines, make_number (frame_lines - 1 - top_margin));
+ WSET (root, total_cols, make_number (frame_cols));
/* Do it for the mini-buffer window. */
- XSETFASTINT (WVAR (mini, top_line), frame_lines - 1);
- XSETFASTINT (WVAR (mini, total_lines), 1);
- XSETFASTINT (WVAR (mini, total_cols), frame_cols);
+ WSET (mini, top_line, make_number (frame_lines - 1));
+ WSET (mini, total_lines, make_number (1));
+ WSET (mini, total_cols, make_number (frame_cols));
adjust_frame_glyphs (sf);
glyphs_initialized_initially_p = 1;
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
+ if (!NILP (WGET (w, hchild)))
{
- if (showing_window_margins_p (XWINDOW (WVAR (w, hchild))))
+ if (showing_window_margins_p (XWINDOW (WGET (w, hchild))))
return 1;
}
- else if (!NILP (WVAR (w, vchild)))
+ else if (!NILP (WGET (w, vchild)))
{
- if (showing_window_margins_p (XWINDOW (WVAR (w, vchild))))
+ if (showing_window_margins_p (XWINDOW (WGET (w, vchild))))
return 1;
}
- else if (!NILP (WVAR (w, left_margin_cols))
- || !NILP (WVAR (w, right_margin_cols)))
+ else if (!NILP (WGET (w, left_margin_cols))
+ || !NILP (WGET (w, right_margin_cols)))
return 1;
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
return 0;
}
{
struct window *w;
- for (; !NILP (window); window = WVAR (w, next))
+ for (; !NILP (window); window = WGET (w, next))
{
w = XWINDOW (window);
- if (!NILP (WVAR (w, hchild)))
- fake_current_matrices (WVAR (w, hchild));
- else if (!NILP (WVAR (w, vchild)))
- fake_current_matrices (WVAR (w, vchild));
+ if (!NILP (WGET (w, hchild)))
+ fake_current_matrices (WGET (w, hchild));
+ else if (!NILP (WGET (w, vchild)))
+ fake_current_matrices (WGET (w, vchild));
else
{
int i;
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph_matrix *m = w->current_matrix;
struct glyph_matrix *fm = f->current_matrix;
struct window *w;
if (NILP (FGET (f, menu_bar_window)))
{
+ Lisp_Object frame;
FSET (f, menu_bar_window, make_window ());
w = XWINDOW (FGET (f, menu_bar_window));
- XSETFRAME (WVAR (w, frame), f);
+ XSETFRAME (frame, f);
+ WSET (w, frame, frame);
w->pseudo_window_p = 1;
}
else
/* Set window dimensions to frame dimensions and allocate or
adjust glyph matrices of W. */
- XSETFASTINT (WVAR (w, top_line), 0);
- XSETFASTINT (WVAR (w, left_col), 0);
- XSETFASTINT (WVAR (w, total_lines), FRAME_MENU_BAR_LINES (f));
- XSETFASTINT (WVAR (w, total_cols), FRAME_TOTAL_COLS (f));
+ WSET (w, top_line, make_number (0));
+ WSET (w, left_col, make_number (0));
+ WSET (w, total_lines, make_number (FRAME_MENU_BAR_LINES (f)));
+ WSET (w, total_cols, make_number (FRAME_TOTAL_COLS (f)));
allocate_matrices_for_window_redisplay (w);
}
#endif /* not USE_X_TOOLKIT && not USE_GTK */
struct window *w;
if (NILP (FGET (f, tool_bar_window)))
{
+ Lisp_Object frame;
FSET (f, tool_bar_window, make_window ());
w = XWINDOW (FGET (f, tool_bar_window));
- XSETFRAME (WVAR (w, frame), f);
+ XSETFRAME (frame, f);
+ WSET (w, frame, frame);
w->pseudo_window_p = 1;
}
else
w = XWINDOW (FGET (f, tool_bar_window));
- XSETFASTINT (WVAR (w, top_line), FRAME_MENU_BAR_LINES (f));
- XSETFASTINT (WVAR (w, left_col), 0);
- XSETFASTINT (WVAR (w, total_lines), FRAME_TOOL_BAR_LINES (f));
- XSETFASTINT (WVAR (w, total_cols), FRAME_TOTAL_COLS (f));
+ WSET (w, top_line, make_number (FRAME_MENU_BAR_LINES (f)));
+ WSET (w, left_col, make_number (0));
+ WSET (w, total_lines, make_number (FRAME_TOOL_BAR_LINES (f)));
+ WSET (w, total_cols, make_number (FRAME_TOTAL_COLS (f)));
allocate_matrices_for_window_redisplay (w);
}
#endif
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- free_window_matrices (XWINDOW (WVAR (w, hchild)));
- else if (!NILP (WVAR (w, vchild)))
- free_window_matrices (XWINDOW (WVAR (w, vchild)));
+ if (!NILP (WGET (w, hchild)))
+ free_window_matrices (XWINDOW (WGET (w, hchild)));
+ else if (!NILP (WGET (w, vchild)))
+ free_window_matrices (XWINDOW (WGET (w, vchild)));
else
{
/* This is a leaf window. Free its memory and reset fields
}
/* Next window on same level. */
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- build_frame_matrix_from_window_tree (matrix, XWINDOW (WVAR (w, hchild)));
- else if (!NILP (WVAR (w, vchild)))
- build_frame_matrix_from_window_tree (matrix, XWINDOW (WVAR (w, vchild)));
+ if (!NILP (WGET (w, hchild)))
+ build_frame_matrix_from_window_tree (matrix, XWINDOW (WGET (w, hchild)));
+ else if (!NILP (WGET (w, vchild)))
+ build_frame_matrix_from_window_tree (matrix, XWINDOW (WGET (w, vchild)));
else
build_frame_matrix_from_leaf_window (matrix, w);
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
/* Convert the glyph's specified face to a realized (cache) face. */
if (lface_id > 0)
{
- int face_id = merge_faces (XFRAME (WVAR (w, frame)),
+ int face_id = merge_faces (XFRAME (WGET (w, frame)),
Qt, lface_id, DEFAULT_FACE_ID);
SET_GLYPH_FACE (*glyph, face_id);
}
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- mirror_make_current (XWINDOW (WVAR (w, hchild)), frame_row);
- else if (!NILP (WVAR (w, vchild)))
- mirror_make_current (XWINDOW (WVAR (w, vchild)), frame_row);
+ if (!NILP (WGET (w, hchild)))
+ mirror_make_current (XWINDOW (WGET (w, hchild)), frame_row);
+ else if (!NILP (WGET (w, vchild)))
+ mirror_make_current (XWINDOW (WGET (w, vchild)), frame_row);
else
{
/* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
}
}
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
static void
sync_window_with_frame_matrix_rows (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph_row *window_row, *window_row_end, *frame_row;
int left, right, x, width;
/* Preconditions: W must be a leaf window on a tty frame. */
- eassert (NILP (WVAR (w, hchild)) && NILP (WVAR (w, vchild)));
+ eassert (NILP (WGET (w, hchild)) && NILP (WGET (w, vchild)));
eassert (!FRAME_WINDOW_P (f));
- left = margin_glyphs_to_reserve (w, 1, WVAR (w, left_margin_cols));
- right = margin_glyphs_to_reserve (w, 1, WVAR (w, right_margin_cols));
+ left = margin_glyphs_to_reserve (w, 1, WGET (w, left_margin_cols));
+ right = margin_glyphs_to_reserve (w, 1, WGET (w, right_margin_cols));
x = w->current_matrix->matrix_x;
width = w->current_matrix->matrix_w;
while (w && !found)
{
- if (!NILP (WVAR (w, hchild)))
- found = frame_row_to_window (XWINDOW (WVAR (w, hchild)), row);
- else if (!NILP (WVAR (w, vchild)))
- found = frame_row_to_window (XWINDOW (WVAR (w, vchild)), row);
+ if (!NILP (WGET (w, hchild)))
+ found = frame_row_to_window (XWINDOW (WGET (w, hchild)), row);
+ else if (!NILP (WGET (w, vchild)))
+ found = frame_row_to_window (XWINDOW (WGET (w, vchild)), row);
else if (row >= WINDOW_TOP_EDGE_LINE (w)
&& row < WINDOW_BOTTOM_EDGE_LINE (w))
found = w;
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
return found;
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- mirror_line_dance (XWINDOW (WVAR (w, hchild)), unchanged_at_top,
+ if (!NILP (WGET (w, hchild)))
+ mirror_line_dance (XWINDOW (WGET (w, hchild)), unchanged_at_top,
nlines, copy_from, retained_p);
- else if (!NILP (WVAR (w, vchild)))
- mirror_line_dance (XWINDOW (WVAR (w, vchild)), unchanged_at_top,
+ else if (!NILP (WGET (w, vchild)))
+ mirror_line_dance (XWINDOW (WGET (w, vchild)), unchanged_at_top,
nlines, copy_from, retained_p);
else
{
{
/* A copy between windows. This is an infrequent
case not worth optimizing. */
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
struct window *w2;
struct glyph_matrix *m2;
}
/* Next window on same level. */
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- check_window_matrix_pointers (XWINDOW (WVAR (w, hchild)));
- else if (!NILP (WVAR (w, vchild)))
- check_window_matrix_pointers (XWINDOW (WVAR (w, vchild)));
+ if (!NILP (WGET (w, hchild)))
+ check_window_matrix_pointers (XWINDOW (WGET (w, hchild)));
+ else if (!NILP (WGET (w, vchild)))
+ check_window_matrix_pointers (XWINDOW (WGET (w, vchild)));
else
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
check_matrix_pointers (w->desired_matrix, f->desired_matrix);
check_matrix_pointers (w->current_matrix, f->current_matrix);
}
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
static int
window_to_frame_vpos (struct window *w, int vpos)
{
- eassert (!FRAME_WINDOW_P (XFRAME (WVAR (w, frame))));
+ eassert (!FRAME_WINDOW_P (XFRAME (WGET (w, frame))));
eassert (vpos >= 0 && vpos <= w->desired_matrix->nrows);
vpos += WINDOW_TOP_EDGE_LINE (w);
- eassert (vpos >= 0 && vpos <= FRAME_LINES (XFRAME (WVAR (w, frame))));
+ eassert (vpos >= 0 && vpos <= FRAME_LINES (XFRAME (WGET (w, frame))));
return vpos;
}
static int
window_to_frame_hpos (struct window *w, int hpos)
{
- eassert (!FRAME_WINDOW_P (XFRAME (WVAR (w, frame))));
+ eassert (!FRAME_WINDOW_P (XFRAME (WGET (w, frame))));
hpos += WINDOW_LEFT_EDGE_COL (w);
return hpos;
}
while (w && !paused_p)
{
- if (!NILP (WVAR (w, hchild)))
- paused_p |= update_window_tree (XWINDOW (WVAR (w, hchild)), force_p);
- else if (!NILP (WVAR (w, vchild)))
- paused_p |= update_window_tree (XWINDOW (WVAR (w, vchild)), force_p);
+ if (!NILP (WGET (w, hchild)))
+ paused_p |= update_window_tree (XWINDOW (WGET (w, hchild)), force_p);
+ else if (!NILP (WGET (w, vchild)))
+ paused_p |= update_window_tree (XWINDOW (WGET (w, vchild)), force_p);
else if (w->must_be_updated_p)
paused_p |= update_window (w, force_p);
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
return paused_p;
struct glyph *glyph = ¤t_row->glyphs[TEXT_AREA][i - 1];
int left, right;
- rif->get_glyph_overhangs (glyph, XFRAME (WVAR (w, frame)),
+ rif->get_glyph_overhangs (glyph, XFRAME (WGET (w, frame)),
&left, &right);
can_skip_p = (right == 0 && !abort_skipping);
}
int left, right;
rif->get_glyph_overhangs (current_glyph,
- XFRAME (WVAR (w, frame)),
+ XFRAME (WGET (w, frame)),
&left, &right);
while (left > 0 && i > 0)
{
/* Update display of the left margin area, if there is one. */
if (!desired_row->full_width_p
- && !NILP (WVAR (w, left_margin_cols)))
+ && !NILP (WGET (w, left_margin_cols)))
{
changed_p = 1;
update_marginal_area (w, LEFT_MARGIN_AREA, vpos);
/* Update display of the right margin area, if there is one. */
if (!desired_row->full_width_p
- && !NILP (WVAR (w, right_margin_cols)))
+ && !NILP (WGET (w, right_margin_cols)))
{
changed_p = 1;
update_marginal_area (w, RIGHT_MARGIN_AREA, vpos);
static void
set_window_cursor_after_update (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct redisplay_interface *rif = FRAME_RIF (f);
int cx, cy, vpos, hpos;
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- set_window_update_flags (XWINDOW (WVAR (w, hchild)), on_p);
- else if (!NILP (WVAR (w, vchild)))
- set_window_update_flags (XWINDOW (WVAR (w, vchild)), on_p);
+ if (!NILP (WGET (w, hchild)))
+ set_window_update_flags (XWINDOW (WGET (w, hchild)), on_p);
+ else if (!NILP (WGET (w, vchild)))
+ set_window_update_flags (XWINDOW (WGET (w, vchild)), on_p);
else
w->must_be_updated_p = on_p;
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
- if (INTEGERP (WVAR (w, left_margin_cols)))
- x += XFASTINT (WVAR (w, left_margin_cols));
+ if (INTEGERP (WGET (w, left_margin_cols)))
+ x += XFASTINT (WGET (w, left_margin_cols));
/* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
cursor_to (f, y, x);
/* We used to set current_buffer directly here, but that does the
wrong thing with `face-remapping-alist' (bug#2044). */
- Fset_buffer (WVAR (w, buffer));
+ Fset_buffer (WGET (w, buffer));
itdata = bidi_shelve_cache ();
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
start_display (&it, w, startp);
*dx = x0 + it.first_visible_x - it.current_x;
*dy = *y - it.current_y;
- string = WVAR (w, buffer);
+ string = WGET (w, buffer);
if (STRINGP (it.string))
string = it.string;
*pos = it.current;
if (STRINGP (it.string))
BYTEPOS (pos->pos) = string_char_to_byte (string, CHARPOS (pos->pos));
else
- BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (WVAR (w, buffer)),
+ BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (WGET (w, buffer)),
CHARPOS (pos->pos));
}
FrameCols (FRAME_TTY (f)) = newwidth;
if (WINDOWP (FGET (f, tool_bar_window)))
- XSETFASTINT (WVAR (XWINDOW (FGET (f, tool_bar_window)), total_cols), newwidth);
+ WSET (XWINDOW (FGET (f, tool_bar_window)),
+ total_cols, make_number (newwidth));
}
FRAME_LINES (f) = newheight;
if (NILP (object))
XSETBUFFER (object, current_buffer);
else if (WINDOWP (object))
- object = WVAR (XWINDOW (object), buffer);
+ object = WGET (XWINDOW (object), buffer);
if (!BUFFERP (object))
/* pos-property only makes sense in buffers right now, since strings
Lisp_Object
save_excursion_save (void)
{
- int visible = (XBUFFER (WVAR (XWINDOW (selected_window), buffer))
+ int visible = (XBUFFER (WGET (XWINDOW (selected_window), buffer))
== current_buffer);
return Fcons (Fpoint_marker (),
and cleaner never to alter the window/buffer connections. */
tem1 = Fcar (tem);
if (!NILP (tem1)
- && current_buffer != XBUFFER (WVAR (XWINDOW (selected_window), buffer)))
+ && current_buffer != XBUFFER (WGET (XWINDOW (selected_window), buffer)))
Fswitch_to_buffer (Fcurrent_buffer (), Qnil);
#endif /* 0 */
tem = XCDR (info);
if (visible_p
&& !EQ (tem, selected_window)
- && (tem1 = WVAR (XWINDOW (tem), buffer),
+ && (tem1 = WGET (XWINDOW (tem), buffer),
(/* Window is live... */
BUFFERP (tem1)
/* ...and it shows the current buffer. */
/* If display currently starts at beginning of line,
keep it that way. */
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) == current_buffer)
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) == current_buffer)
XWINDOW (selected_window)->start_at_line_beg = !NILP (Fbolp ());
replace_handled = 1;
/* If display currently starts at beginning of line,
keep it that way. */
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) == current_buffer)
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) == current_buffer)
XWINDOW (selected_window)->start_at_line_beg = !NILP (Fbolp ());
/* Replace the chars that we need to replace,
}
}
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
if (! FRAME_WINDOW_P (f))
return Qnil;
if (! face)
face_id = face_at_buffer_position (w, pos, 0, 0, &ignore,
*limit, 0, -1);
- face = FACE_FROM_ID (XFRAME (WVAR (w, frame)), face_id);
+ face = FACE_FROM_ID (XFRAME (WGET (w, frame)), face_id);
}
}
else
if (NILP (window))
return Qnil;
w = XWINDOW (window);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
face_id = face_at_buffer_position (w, pos, -1, -1, &dummy,
pos + 100, 0, -1);
}
struct window *w = XWINDOW (window);
w->last_modified = 0;
- XSETFASTINT (WVAR (w, top_line), XFASTINT (WVAR (w, top_line)) + n);
- XSETFASTINT (WVAR (w, total_lines), XFASTINT (WVAR (w, total_lines)) - n);
+ WSET (w, top_line, make_number (XFASTINT (WGET (w, top_line)) + n));
+ WSET (w, total_lines, make_number (XFASTINT (WGET (w, total_lines)) - n));
/* Handle just the top child in a vertical split. */
- if (!NILP (WVAR (w, vchild)))
- set_menu_bar_lines_1 (WVAR (w, vchild), n);
+ if (!NILP (WGET (w, vchild)))
+ set_menu_bar_lines_1 (WGET (w, vchild), n);
/* Adjust all children in a horizontal split. */
- for (window = WVAR (w, hchild); !NILP (window); window = WVAR (w, next))
+ for (window = WGET (w, hchild); !NILP (window); window = WGET (w, next))
{
w = XWINDOW (window);
set_menu_bar_lines_1 (window, n);
if (mini_p)
{
mini_window = make_window ();
- WVAR (XWINDOW (root_window), next) = mini_window;
- WVAR (XWINDOW (mini_window), prev) = root_window;
+ WSET (XWINDOW (root_window), next, mini_window);
+ WSET (XWINDOW (mini_window), prev, root_window);
XWINDOW (mini_window)->mini = 1;
- WVAR (XWINDOW (mini_window), frame) = frame;
+ WSET (XWINDOW (mini_window), frame, frame);
FSET (f, minibuffer_window, mini_window);
}
else
{
mini_window = Qnil;
- WVAR (XWINDOW (root_window), next) = Qnil;
+ WSET (XWINDOW (root_window), next, Qnil);
FSET (f, minibuffer_window, Qnil);
}
- WVAR (XWINDOW (root_window), frame) = frame;
+ WSET (XWINDOW (root_window), frame, frame);
/* 10 is arbitrary,
just so that there is "something there."
SET_FRAME_COLS (f, 10);
FRAME_LINES (f) = 10;
- XSETFASTINT (WVAR (XWINDOW (root_window), total_cols), 10);
- XSETFASTINT (WVAR (XWINDOW (root_window), total_lines), (mini_p ? 9 : 10));
+ WSET (XWINDOW (root_window), total_cols, make_number (10));
+ WSET (XWINDOW (root_window), total_lines, make_number (mini_p ? 9 : 10));
if (mini_p)
{
- XSETFASTINT (WVAR (XWINDOW (mini_window), total_cols), 10);
- XSETFASTINT (WVAR (XWINDOW (mini_window), top_line), 9);
- XSETFASTINT (WVAR (XWINDOW (mini_window), total_lines), 1);
+ WSET (XWINDOW (mini_window), total_cols, make_number (10));
+ WSET (XWINDOW (mini_window), top_line, make_number (9));
+ WSET (XWINDOW (mini_window), total_lines, make_number (1));
}
/* Choose a buffer for the frame's root window. */
{
Lisp_Object buf;
- WVAR (XWINDOW (root_window), buffer) = Qt;
+ WSET (XWINDOW (root_window), buffer, Qt);
buf = Fcurrent_buffer ();
/* If buf is a 'hidden' buffer (i.e. one whose name starts with
a space), try to find another one. */
if (mini_p)
{
- WVAR (XWINDOW (mini_window), buffer) = Qt;
+ WSET (XWINDOW (mini_window), buffer, Qt);
set_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
CHECK_LIVE_WINDOW (mini_window);
if (!NILP (mini_window)
- && FRAME_KBOARD (XFRAME (WVAR (XWINDOW (mini_window), frame))) != kb)
+ && FRAME_KBOARD (XFRAME (WGET (XWINDOW (mini_window), frame))) != kb)
error ("Frame and minibuffer must be on the same terminal");
/* Make a frame containing just a root window. */
/* Make the chosen minibuffer window display the proper minibuffer,
unless it is already showing a minibuffer. */
- if (NILP (Fmemq (WVAR (XWINDOW (mini_window), buffer), Vminibuffer_list)))
+ if (NILP (Fmemq (WGET (XWINDOW (mini_window), buffer), Vminibuffer_list)))
Fset_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
mini_window = FSET (f, minibuffer_window, FGET (f, root_window));
XWINDOW (mini_window)->mini = 1;
- WVAR (XWINDOW (mini_window), next) = Qnil;
- WVAR (XWINDOW (mini_window), prev) = Qnil;
- WVAR (XWINDOW (mini_window), frame) = frame;
+ WSET (XWINDOW (mini_window), next, Qnil);
+ WSET (XWINDOW (mini_window), prev, Qnil);
+ WSET (XWINDOW (mini_window), frame, frame);
/* Put the proper buffer in that window. */
if (EQ (FGET (f, minibuffer_window), minibuf_window))
{
Fset_window_buffer (FGET (sf, minibuffer_window),
- WVAR (XWINDOW (minibuf_window), buffer), Qnil);
+ WGET (XWINDOW (minibuf_window), buffer), Qnil);
minibuf_window = FGET (sf, minibuffer_window);
/* If the dying minibuffer window was selected,
{
struct window *w;
- for (;!NILP (window); window = WVAR (w, next))
+ for (;!NILP (window); window = WGET (w, next))
{
w = XWINDOW (window);
- if (!NILP (WVAR (w, buffer)))
- BVAR (XBUFFER (WVAR (w, buffer)), display_time) = Fcurrent_time ();
+ if (!NILP (WGET (w, buffer)))
+ BVAR (XBUFFER (WGET (w, buffer)), display_time) = Fcurrent_time ();
- if (!NILP (WVAR (w, vchild)))
- make_frame_visible_1 (WVAR (w, vchild));
- if (!NILP (WVAR (w, hchild)))
- make_frame_visible_1 (WVAR (w, hchild));
+ if (!NILP (WGET (w, vchild)))
+ make_frame_visible_1 (WGET (w, vchild));
+ if (!NILP (WGET (w, hchild)))
+ make_frame_visible_1 (WGET (w, hchild));
}
}
{
struct frame *sf = XFRAME (selected_frame);
Fset_window_buffer (FGET (sf, minibuffer_window),
- WVAR (XWINDOW (minibuf_window), buffer), Qnil);
+ WGET (XWINDOW (minibuf_window), buffer), Qnil);
minibuf_window = FGET (sf, minibuffer_window);
}
{
struct frame *sf = XFRAME (selected_frame);
Fset_window_buffer (FGET (sf, minibuffer_window),
- WVAR (XWINDOW (minibuf_window), buffer), Qnil);
+ WGET (XWINDOW (minibuf_window), buffer), Qnil);
minibuf_window = FGET (sf, minibuffer_window);
}
#define XSETFRAME(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FRAME))
/* Given a window, return its frame as a Lisp_Object. */
-#define WINDOW_FRAME(w) WVAR (w, frame)
+#define WINDOW_FRAME(w) WGET (w, frame)
/* Test a frame for particular kinds of display methods. */
#define FRAME_INITIAL_P(f) ((f)->output_method == output_initial)
{
Lisp_Object cmap, bm = Qnil;
- if ((cmap = BVAR (XBUFFER (WVAR (w, buffer)), fringe_cursor_alist)), !NILP (cmap))
+ if ((cmap = BVAR (XBUFFER (WGET (w, buffer)), fringe_cursor_alist)), !NILP (cmap))
{
bm = Fassq (cursor, cmap);
if (CONSP (bm))
If partial, lookup partial bitmap in default value if not found here.
If not partial, or no partial spec is present, use non-partial bitmap. */
- if ((cmap = BVAR (XBUFFER (WVAR (w, buffer)), fringe_indicator_alist)), !NILP (cmap))
+ if ((cmap = BVAR (XBUFFER (WGET (w, buffer)), fringe_indicator_alist)), !NILP (cmap))
{
bm1 = Fassq (bitmap, cmap);
if (CONSP (bm1))
return 0;
if (!MINI_WINDOW_P (w)
- && (ind = BVAR (XBUFFER (WVAR (w, buffer)), indicate_buffer_boundaries), !NILP (ind)))
+ && (ind = BVAR (XBUFFER (WGET (w, buffer)), indicate_buffer_boundaries), !NILP (ind)))
{
if (EQ (ind, Qleft) || EQ (ind, Qright))
boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
{
if (top_ind_rn < 0 && row->visible_height > 0)
{
- if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (WVAR (w, buffer)))
+ if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (WGET (w, buffer)))
&& !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
row->indicate_bob_p = !NILP (boundary_top);
else
if (bot_ind_rn < 0)
{
- if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (WVAR (w, buffer)))
+ if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (WGET (w, buffer)))
&& !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row))
row->indicate_eob_p = !NILP (boundary_bot), bot_ind_rn = rn;
else if (y + row->height >= yb)
}
}
- empty_pos = BVAR (XBUFFER (WVAR (w, buffer)), indicate_empty_lines);
+ empty_pos = BVAR (XBUFFER (WGET (w, buffer)), indicate_empty_lines);
if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
else if (w == XWINDOW (selected_window))
textpos = PT;
else
- textpos = XMARKER (WVAR (w, pointm))->charpos;
+ textpos = XMARKER (WGET (w, pointm))->charpos;
row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
row = row_containing_pos (w, textpos, row, NULL, 0);
the next property change */
prop = Fget_char_property (position, Qinvisible,
(!NILP (window)
- && EQ (WVAR (XWINDOW (window), buffer), buffer))
+ && EQ (WGET (XWINDOW (window), buffer), buffer))
? window : buffer);
inv_p = TEXT_PROP_MEANS_INVISIBLE (prop);
/* When counting columns (window == nil), don't skip over ellipsis text. */
width = window_body_cols (win);
/* We must make room for continuation marks if we don't have fringes. */
#ifdef HAVE_WINDOW_SYSTEM
- if (!FRAME_WINDOW_P (XFRAME (WVAR (win, frame))))
+ if (!FRAME_WINDOW_P (XFRAME (WGET (win, frame))))
#endif
width -= 1;
}
continuation_glyph_width = 1;
#ifdef HAVE_WINDOW_SYSTEM
- if (FRAME_WINDOW_P (XFRAME (WVAR (win, frame))))
+ if (FRAME_WINDOW_P (XFRAME (WGET (win, frame))))
continuation_glyph_width = 0; /* In the fringe. */
#endif
? (window_body_cols (w)
- (
#ifdef HAVE_WINDOW_SYSTEM
- FRAME_WINDOW_P (XFRAME (WVAR (w, frame))) ? 0 :
+ FRAME_WINDOW_P (XFRAME (WGET (w, frame))) ? 0 :
#endif
1))
: XINT (XCAR (topos))),
/* If the window contains this buffer, use it for getting text properties.
Otherwise use the current buffer as arg for doing that. */
- if (EQ (WVAR (w, buffer), Fcurrent_buffer ()))
+ if (EQ (WGET (w, buffer), Fcurrent_buffer ()))
text_prop_object = window;
else
text_prop_object = Fcurrent_buffer ();
old_buffer = Qnil;
GCPRO3 (old_buffer, old_charpos, old_bytepos);
- if (XBUFFER (WVAR (w, buffer)) != current_buffer)
+ if (XBUFFER (WGET (w, buffer)) != current_buffer)
{
/* Set the window's buffer temporarily to the current buffer. */
- old_buffer = WVAR (w, buffer);
- old_charpos = XMARKER (WVAR (w, pointm))->charpos;
- old_bytepos = XMARKER (WVAR (w, pointm))->bytepos;
- XSETBUFFER (WVAR (w, buffer), current_buffer);
- set_marker_both (WVAR (w, pointm), WVAR (w, buffer),
+ old_buffer = WGET (w, buffer);
+ old_charpos = XMARKER (WGET (w, pointm))->charpos;
+ old_bytepos = XMARKER (WGET (w, pointm))->bytepos;
+ WSET (w, buffer, Fcurrent_buffer ());
+ set_marker_both (WGET (w, pointm), WGET (w, buffer),
BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
}
}
move_it_in_display_line
(&it, ZV,
- (int)(cols * FRAME_COLUMN_WIDTH (XFRAME (WVAR (w, frame))) + 0.5),
+ (int)(cols * FRAME_COLUMN_WIDTH (XFRAME (WGET (w, frame))) + 0.5),
MOVE_TO_X);
}
if (BUFFERP (old_buffer))
{
- WVAR (w, buffer) = old_buffer;
- set_marker_both (WVAR (w, pointm), WVAR (w, buffer),
+ WSET (w, buffer, old_buffer);
+ set_marker_both (WGET (w, pointm), WGET (w, buffer),
old_charpos, old_bytepos);
}
/* Let redisplay consider other windows than selected_window
if modifying another buffer. */
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) != current_buffer)
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) != current_buffer)
++windows_or_buffers_changed;
if (BUF_INTERVALS (current_buffer) != 0)
update_mode_lines = 1;
if (command_loop_level
- && current_buffer != XBUFFER (WVAR (XWINDOW (selected_window), buffer)))
+ && current_buffer != XBUFFER (WGET (XWINDOW (selected_window), buffer)))
buffer = Fcurrent_buffer ();
else
buffer = Qnil;
Fkill_emacs (Qnil);
/* Make sure the current window's buffer is selected. */
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) != current_buffer)
- set_buffer_internal (XBUFFER (WVAR (XWINDOW (selected_window), buffer)));
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) != current_buffer)
+ set_buffer_internal (XBUFFER (WGET (XWINDOW (selected_window), buffer)));
/* Display any malloc warning that just came out. Use while because
displaying one warning can cause another. */
/* A filter may have run while we were reading the input. */
if (! FRAME_LIVE_P (XFRAME (selected_frame)))
Fkill_emacs (Qnil);
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) != current_buffer)
- set_buffer_internal (XBUFFER (WVAR (XWINDOW (selected_window), buffer)));
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) != current_buffer)
+ set_buffer_internal (XBUFFER (WGET (XWINDOW (selected_window), buffer)));
++num_input_keys;
{
struct buffer *b;
XWINDOW (selected_window)->force_start = 0;
- b = XBUFFER (WVAR (XWINDOW (selected_window), buffer));
+ b = XBUFFER (WGET (XWINDOW (selected_window), buffer));
BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
}
if (STRINGP (string))
string_info = Fcons (string, make_number (charpos));
textpos = (w == XWINDOW (selected_window)
- && current_buffer == XBUFFER (WVAR (w, buffer)))
- ? PT : XMARKER (WVAR (w, pointm))->charpos;
+ && current_buffer == XBUFFER (WGET (w, buffer)))
+ ? PT : XMARKER (WGET (w, pointm))->charpos;
xret = wx;
yret = wy;
int fuzz;
if (WINDOWP (event->frame_or_window))
- f = XFRAME (WVAR (XWINDOW (event->frame_or_window), frame));
+ f = XFRAME (WGET (XWINDOW (event->frame_or_window), frame));
else if (FRAMEP (event->frame_or_window))
f = XFRAME (event->frame_or_window);
else
int is_double;
if (WINDOWP (event->frame_or_window))
- fr = XFRAME (WVAR (XWINDOW (event->frame_or_window), frame));
+ fr = XFRAME (WGET (XWINDOW (event->frame_or_window), frame));
else if (FRAMEP (event->frame_or_window))
fr = XFRAME (event->frame_or_window);
else
{
if (! FRAME_LIVE_P (XFRAME (selected_frame)))
Fkill_emacs (Qnil);
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) != current_buffer)
- Fset_buffer (WVAR (XWINDOW (selected_window), buffer));
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) != current_buffer)
+ Fset_buffer (WGET (XWINDOW (selected_window), buffer));
}
orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
not the current buffer. If we're at the
beginning of a key sequence, switch buffers. */
if (WINDOWP (window)
- && BUFFERP (WVAR (XWINDOW (window), buffer))
- && XBUFFER (WVAR (XWINDOW (window), buffer)) != current_buffer)
+ && BUFFERP (WGET (XWINDOW (window), buffer))
+ && XBUFFER (WGET (XWINDOW (window), buffer)) != current_buffer)
{
ASET (raw_keybuf, raw_keybuf_count, key);
raw_keybuf_count++;
if (! FRAME_LIVE_P (XFRAME (selected_frame)))
Fkill_emacs (Qnil);
- set_buffer_internal (XBUFFER (WVAR (XWINDOW (window), buffer)));
+ set_buffer_internal (XBUFFER (WGET (XWINDOW (window), buffer)));
orig_local_map = get_local_map (PT, current_buffer,
Qlocal_map);
orig_keymap = get_local_map (PT, current_buffer,
? window_box_left_offset (w, TEXT_AREA)
: 0)));
XSETINT (y, WINDOW_TO_FRAME_PIXEL_Y (w, XINT (y)));
- frame_or_window = WVAR (w, frame);
+ frame_or_window = WGET (w, frame);
}
CHECK_LIVE_FRAME (frame_or_window);
window = POSN_WINDOW (position);
if (WINDOWP (window)
- && BUFFERP (WVAR (XWINDOW (window), buffer))
- && XBUFFER (WVAR (XWINDOW (window), buffer)) != current_buffer)
+ && BUFFERP (WGET (XWINDOW (window), buffer))
+ && XBUFFER (WGET (XWINDOW (window), buffer)) != current_buffer)
{
/* Arrange to go back to the original buffer once we're done
processing the key sequence. We don't use
record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
- set_buffer_internal (XBUFFER (WVAR (XWINDOW (window), buffer)));
+ set_buffer_internal (XBUFFER (WGET (XWINDOW (window), buffer)));
}
}
vchild, and hchild members are all nil. */
#define CHECK_LIVE_WINDOW(x) \
- CHECK_TYPE (WINDOWP (x) && !NILP (WVAR (XWINDOW (x), buffer)), \
+ CHECK_TYPE (WINDOWP (x) && !NILP (WGET (XWINDOW (x), buffer)), \
Qwindow_live_p, x)
#define CHECK_PROCESS(x) \
/* Under X, we come here with minibuf_window being the
minibuffer window of the unused termcap window created in
init_window_once. That window doesn't have a buffer. */
- buffer = WVAR (XWINDOW (minibuf_window), buffer);
+ buffer = WGET (XWINDOW (minibuf_window), buffer);
if (BUFFERP (buffer))
Fset_window_buffer (FGET (sf, minibuffer_window), buffer, Qnil);
minibuf_window = FGET (sf, minibuffer_window);
FOR_EACH_FRAME (dummy, frame)
{
Lisp_Object root_window = Fframe_root_window (frame);
- Lisp_Object mini_window = WVAR (XWINDOW (root_window), next);
+ Lisp_Object mini_window = WGET (XWINDOW (root_window), next);
if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
&& !NILP (Fwindow_minibuffer_p (mini_window)))
XWINDOW (minibuf_window)->must_be_updated_p = 1;
update_frame (XFRAME (selected_frame), 1, 1);
{
- struct frame *f = XFRAME (WVAR (XWINDOW (minibuf_window), frame));
+ struct frame *f = XFRAME (WGET (XWINDOW (minibuf_window), frame));
struct redisplay_interface *rif = FRAME_RIF (f);
if (rif && rif->flush_display)
rif->flush_display (f);
window = minibuf_window;
/* To keep things predictable, in case it matters, let's be in the
minibuffer when we reset the relevant variables. */
- Fset_buffer (WVAR (XWINDOW (window), buffer));
+ Fset_buffer (WGET (XWINDOW (window), buffer));
/* Restore prompt, etc, from outer minibuffer level. */
minibuf_prompt = Fcar (minibuf_save_list);
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
Lisp_Object window = hlinfo->mouse_face_window;
- if (! NILP (window) && XFRAME (WVAR (XWINDOW (window), frame)) == f)
+ if (! NILP (window) && XFRAME (WGET (XWINDOW (window), frame)) == f)
{
hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
/* If the mouse highlight is in the window that was deleted
(e.g., if it was popped by completion), clear highlight
unconditionally. */
- if (NILP (WVAR (w, buffer)))
+ if (NILP (WGET (w, buffer)))
hlinfo->mouse_face_window = Qnil;
else
{
break;
}
- if (NILP (WVAR (w, buffer)) || i < w->desired_matrix->nrows)
+ if (NILP (WGET (w, buffer)) || i < w->desired_matrix->nrows)
clear_mouse_face (hlinfo);
}
}
new_cursor = frame_desired_cursor;
else
{
- struct buffer *b = XBUFFER (WVAR (sw, buffer));
+ struct buffer *b = XBUFFER (WGET (sw, buffer));
if (EQ (BVAR (b,cursor_type), Qt))
new_cursor = frame_desired_cursor;
{
NSView *view;
Lisp_Object name, filename;
- Lisp_Object buf = WVAR (XWINDOW (FGET (f, selected_window)), buffer);
+ Lisp_Object buf = WGET (XWINDOW (FGET (f, selected_window)), buffer);
const char *title;
NSAutoreleasePool *pool;
struct gcpro gcpro1;
= alloca (previous_menu_items_used * sizeof *previous_items);
/* lisp preliminaries */
- buffer = WVAR (XWINDOW (FRAME_SELECTED_WINDOW (f)), buffer);
+ buffer = WGET (XWINDOW (FRAME_SELECTED_WINDOW (f)), buffer);
specbind (Qinhibit_quit, Qt);
specbind (Qdebug_on_next_call, Qnil);
record_unwind_save_match_data ();
external (RIF) call; for one window called before update_end
-------------------------------------------------------------------------- */
{
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WVAR (w, frame)));
+ Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WGET (w, frame)));
/* note: this fn is nearly identical in all terms */
if (!w->pseudo_window_p)
External (RIF): Insert or delete n lines at line vpos
-------------------------------------------------------------------------- */
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int x, y, width, height, from_y, to_y, bottom_y;
NSTRACE (ns_scroll_run);
full-width rows stays visible in the internal border.
Under NS this is drawn inside the fringes. */
if (windows_or_buffers_changed
- && (f = XFRAME (WVAR (w, frame)),
+ && (f = XFRAME (WGET (w, frame)),
width = FRAME_INTERNAL_BORDER_WIDTH (f),
width != 0)
&& (height = desired_row->visible_height,
EmacsScroller *bar;
/* optimization; display engine sends WAY too many of these.. */
- if (!NILP (WVAR (window, vertical_scroll_bar)))
+ if (!NILP (WGET (window, vertical_scroll_bar)))
{
- bar = XNS_SCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XNS_SCROLL_BAR (WGET (window, vertical_scroll_bar));
if ([bar checkSamePosition: position portion: portion whole: whole])
{
if (view->scrollbarsNeedingUpdate == 0)
/* we want at least 5 lines to display a scrollbar */
if (WINDOW_TOTAL_LINES (window) < 5)
{
- if (!NILP (WVAR (window, vertical_scroll_bar)))
+ if (!NILP (WGET (window, vertical_scroll_bar)))
{
- bar = XNS_SCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XNS_SCROLL_BAR (WGET (window, vertical_scroll_bar));
[bar removeFromSuperview];
- WVAR (window, vertical_scroll_bar) = Qnil;
+ WSET (window, vertical_scroll_bar, Qnil);
}
ns_clear_frame_area (f, sb_left, top, width, height);
UNBLOCK_INPUT;
return;
}
- if (NILP (WVAR (window, vertical_scroll_bar)))
+ if (NILP (WGET (window, vertical_scroll_bar)))
{
ns_clear_frame_area (f, sb_left, top, width, height);
bar = [[EmacsScroller alloc] initFrame: r window: win];
- WVAR (window, vertical_scroll_bar) = make_save_value (bar, 0);
+ WSET (window, vertical_scroll_bar, make_save_value (bar, 0));
}
else
{
NSRect oldRect;
- bar = XNS_SCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XNS_SCROLL_BAR (WGET (window, vertical_scroll_bar));
oldRect = [bar frame];
r.size.width = oldRect.size.width;
if (FRAME_LIVE_P (f) && !NSEqualRects (oldRect, r))
{
id bar;
NSTRACE (ns_redeem_scroll_bar);
- if (!NILP (WVAR (window, vertical_scroll_bar)))
+ if (!NILP (WGET (window, vertical_scroll_bar)))
{
- bar = XNS_SCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XNS_SCROLL_BAR (WGET (window, vertical_scroll_bar));
[bar reprieve];
}
}
Lisp_Object str = Qnil;
struct frame *f = SELECTED_FRAME ();
struct buffer *curbuf
- = XBUFFER (WVAR (XWINDOW (FGET (f, selected_window)), buffer));
+ = XBUFFER (WGET (XWINDOW (FGET (f, selected_window)), buffer));
if ([attribute isEqualToString:NSAccessibilityRoleAttribute])
return NSAccessibilityTextFieldRole;
if (pixel_height == 0) pixel_height = 1;
min_portion = 20 / pixel_height;
- frame = XFRAME (WVAR (XWINDOW (win), frame));
+ frame = XFRAME (WGET (XWINDOW (win), frame));
if (FRAME_LIVE_P (frame))
{
int i;
{
NSTRACE (EmacsScroller_dealloc);
if (!NILP (win))
- WVAR (XWINDOW (win), vertical_scroll_bar) = Qnil;
+ WSET (XWINDOW (win), vertical_scroll_bar, Qnil);
[super dealloc];
}
strout ("#<window ", -1, -1, printcharfun);
len = sprintf (buf, "%d", XWINDOW (obj)->sequence_number);
strout (buf, len, len, printcharfun);
- if (!NILP (WVAR (XWINDOW (obj), buffer)))
+ if (!NILP (WGET (XWINDOW (obj), buffer)))
{
strout (" on ", -1, -1, printcharfun);
- print_string (BVAR (XBUFFER (WVAR (XWINDOW (obj), buffer)), name),
+ print_string (BVAR (XBUFFER (WGET (XWINDOW (obj), buffer)), name),
printcharfun);
}
PRINTCHAR ('>');
if (WINDOWP (object))
{
w = XWINDOW (object);
- object = WVAR (w, buffer);
+ object = WGET (w, buffer);
}
if (BUFFERP (object))
{
/* Set up the frame's root window. */
w = XWINDOW (FRAME_ROOT_WINDOW (f));
- WVAR (w, left_col) = WVAR (w, top_line) = make_number (0);
+ WSET (w, left_col, make_number (0));
+ WSET (w, top_line, make_number (0));
if (CONSP (Vx_max_tooltip_size)
&& INTEGERP (XCAR (Vx_max_tooltip_size))
&& INTEGERP (XCDR (Vx_max_tooltip_size))
&& XINT (XCDR (Vx_max_tooltip_size)) > 0)
{
- WVAR (w, total_cols) = XCAR (Vx_max_tooltip_size);
- WVAR (w, total_lines) = XCDR (Vx_max_tooltip_size);
+ WSET (w, total_cols, XCAR (Vx_max_tooltip_size));
+ WSET (w, total_lines, XCDR (Vx_max_tooltip_size));
}
else
{
- WVAR (w, total_cols) = make_number (80);
- WVAR (w, total_lines) = make_number (40);
+ WSET (w, total_cols, make_number (80));
+ WSET (w, total_lines, make_number (40));
}
- FRAME_TOTAL_COLS (f) = XINT (WVAR (w, total_cols));
+ FRAME_TOTAL_COLS (f) = XINT (WGET (w, total_cols));
adjust_glyphs (f);
w->pseudo_window_p = 1;
/* Display the tooltip text in a temporary buffer. */
old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (WVAR (XWINDOW (FRAME_ROOT_WINDOW (f)), buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (XWINDOW (FRAME_ROOT_WINDOW (f)), buffer)));
BVAR (current_buffer, truncate_lines) = Qnil;
clear_glyph_matrix (w->desired_matrix);
clear_glyph_matrix (w->current_matrix);
/* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
not in pixels. */
width /= WINDOW_FRAME_COLUMN_WIDTH (w);
- WVAR (w, total_cols) = make_number (width);
+ WSET (w, total_cols, make_number (width));
FRAME_TOTAL_COLS (f) = width;
adjust_glyphs (f);
w->pseudo_window_p = 1;
if (! menubar_widget)
previous_menu_items_used = 0;
- buffer = WVAR (XWINDOW (FRAME_SELECTED_WINDOW (f)), buffer);
+ buffer = WGET (XWINDOW (FRAME_SELECTED_WINDOW (f)), buffer);
specbind (Qinhibit_quit, Qt);
/* Don't let the debugger step into this code
because it is not reentrant. */
x_update_window_end (struct window *w, int cursor_on_p,
int mouse_face_overwritten_p)
{
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WVAR (w, frame)));
+ Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WGET (w, frame)));
if (!w->pseudo_window_p)
{
overhead is very small. */
if (windows_or_buffers_changed
&& desired_row->full_width_p
- && (f = XFRAME (WVAR (w, frame)),
+ && (f = XFRAME (WGET (w, frame)),
width = FRAME_INTERNAL_BORDER_WIDTH (f),
width != 0)
&& (height = desired_row->visible_height,
static void
x_scroll_run (struct window *w, struct run *run)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int x, y, width, height, from_y, to_y, bottom_y;
HWND hwnd = FRAME_W32_WINDOW (f);
HRGN expect_dirty;
my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
/* Dissociate this scroll bar from its window. */
- WVAR (XWINDOW (bar->window), vertical_scroll_bar) = Qnil;
+ WSET (XWINDOW (bar->window), vertical_scroll_bar, Qnil);
UNBLOCK_INPUT;
}
w32_set_vertical_scroll_bar (struct window *w,
int portion, int whole, int position)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct scroll_bar *bar;
int top, height, left, sb_left, width, sb_width;
int window_y, window_height;
|| WINDOW_RIGHT_MARGIN_COLS (w) == 0));
/* Does the scroll bar exist yet? */
- if (NILP (WVAR (w, vertical_scroll_bar)))
+ if (NILP (WGET (w, vertical_scroll_bar)))
{
HDC hdc;
BLOCK_INPUT;
/* It may just need to be moved and resized. */
HWND hwnd;
- bar = XSCROLL_BAR (WVAR (w, vertical_scroll_bar));
+ bar = XSCROLL_BAR (WGET (w, vertical_scroll_bar));
hwnd = SCROLL_BAR_W32_WINDOW (bar);
/* If already correctly positioned, do nothing. */
w32_set_scroll_bar_thumb (bar, portion, position, whole);
- XSETVECTOR (WVAR (w, vertical_scroll_bar), bar);
+ XSETVECTOR (WGET (w, vertical_scroll_bar), bar);
}
struct frame *f;
/* We can't redeem this window's scroll bar if it doesn't have one. */
- if (NILP (WVAR (window, vertical_scroll_bar)))
+ if (NILP (WGET (window, vertical_scroll_bar)))
abort ();
- bar = XSCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XSCROLL_BAR (WGET (window, vertical_scroll_bar));
/* Unlink it from the condemned list. */
f = XFRAME (WINDOW_FRAME (window));
{
/* If the prev pointer is nil, it must be the first in one of
the lists. */
- if (EQ (FRAME_SCROLL_BARS (f), WVAR (window, vertical_scroll_bar)))
+ if (EQ (FRAME_SCROLL_BARS (f), WGET (window, vertical_scroll_bar)))
/* It's not condemned. Everything's fine. */
return;
else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
- WVAR (window, vertical_scroll_bar)))
+ WGET (window, vertical_scroll_bar)))
FSET (f, condemned_scroll_bars, bar->next);
else
/* If its prev pointer is nil, it must be at the front of
create event iff we don't leave the
selected frame. */
&& (focus_follows_mouse
- || (EQ (WVAR (XWINDOW (window), frame),
- WVAR (XWINDOW (selected_window), frame)))))
+ || (EQ (WGET (XWINDOW (window), frame),
+ WGET (XWINDOW (selected_window), frame)))))
{
inev.kind = SELECT_WINDOW_EVENT;
inev.frame_or_window = window;
x_draw_bar_cursor (struct window *w, struct glyph_row *row,
int width, enum text_cursor_kinds kind)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph *cursor_glyph;
/* If cursor is out of bounds, don't draw garbage. This can happen
If WINDOW is omitted or nil, it defaults to the selected window. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), frame);
+ return WGET (decode_any_window (window), frame);
}
DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
window = FGET (XFRAME (frame_or_window), root_window);
}
- while (NILP (WVAR (XWINDOW (window), buffer)))
+ while (NILP (WGET (XWINDOW (window), buffer)))
{
- if (! NILP (WVAR (XWINDOW (window), hchild)))
- window = WVAR (XWINDOW (window), hchild);
- else if (! NILP (WVAR (XWINDOW (window), vchild)))
- window = WVAR (XWINDOW (window), vchild);
+ if (! NILP (WGET (XWINDOW (window), hchild)))
+ window = WGET (XWINDOW (window), hchild);
+ else if (! NILP (WGET (XWINDOW (window), vchild)))
+ window = WGET (XWINDOW (window), vchild);
else
abort ();
}
if (NILP (norecord))
{
w->use_time = ++window_select_count;
- record_buffer (WVAR (w, buffer));
+ record_buffer (WGET (w, buffer));
}
if (EQ (window, selected_window) && !inhibit_point_swap)
if (!inhibit_point_swap)
{
ow = XWINDOW (selected_window);
- if (! NILP (WVAR (ow, buffer)))
- set_marker_both (WVAR (ow, pointm), WVAR (ow, buffer),
- BUF_PT (XBUFFER (WVAR (ow, buffer))),
- BUF_PT_BYTE (XBUFFER (WVAR (ow, buffer))));
+ if (! NILP (WGET (ow, buffer)))
+ set_marker_both (WGET (ow, pointm), WGET (ow, buffer),
+ BUF_PT (XBUFFER (WGET (ow, buffer))),
+ BUF_PT_BYTE (XBUFFER (WGET (ow, buffer))));
}
selected_window = window;
- Fset_buffer (WVAR (w, buffer));
+ Fset_buffer (WGET (w, buffer));
- BVAR (XBUFFER (WVAR (w, buffer)), last_selected_window) = window;
+ BVAR (XBUFFER (WGET (w, buffer)), last_selected_window) = window;
/* Go to the point recorded in the window.
This is important when the buffer is in more
redisplay_window has altered point after scrolling,
because it makes the change only in the window. */
{
- register ptrdiff_t new_point = marker_position (WVAR (w, pointm));
+ register ptrdiff_t new_point = marker_position (WGET (w, pointm));
if (new_point < BEGV)
SET_PT (BEGV);
else if (new_point > ZV)
Return nil for an internal window or a deleted window. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), buffer);
+ return WGET (decode_any_window (window), buffer);
}
DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
Return nil for a window with no parent (e.g. a root window). */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), parent);
+ return WGET (decode_any_window (window), parent);
}
DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 1, 1, 0,
(Lisp_Object window)
{
CHECK_WINDOW (window);
- return WVAR (decode_any_window (window), vchild);
+ return WGET (decode_any_window (window), vchild);
}
DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 1, 1, 0,
(Lisp_Object window)
{
CHECK_WINDOW (window);
- return WVAR (decode_any_window (window), hchild);
+ return WGET (decode_any_window (window), hchild);
}
DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
Return nil if WINDOW has no next sibling. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), next);
+ return WGET (decode_any_window (window), next);
}
DEFUN ("window-prev-sibling", Fwindow_prev_sibling, Swindow_prev_sibling, 0, 1, 0,
Return nil if WINDOW has no previous sibling. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), prev);
+ return WGET (decode_any_window (window), prev);
}
DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
WINDOW are never \(re-)combined with WINDOW's siblings. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), combination_limit);
+ return WGET (decode_any_window (window), combination_limit);
}
DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
for future use. */)
(Lisp_Object window, Lisp_Object limit)
{
- register struct window *w = decode_any_window (window);
- WVAR (w, combination_limit) = limit;
- return WVAR (w, combination_limit);
+ return WSET (decode_any_window (window), combination_limit, limit);
}
DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
integer multiple of the default character height. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), total_lines);
+ return WGET (decode_any_window (window), total_lines);
}
DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 1, 0,
integer multiple of the default character width. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), total_cols);
+ return WGET (decode_any_window (window), total_cols);
}
DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
If WINDOW is omitted or nil, it defaults to the selected window. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), new_total);
+ return WGET (decode_any_window (window), new_total);
}
DEFUN ("window-normal-size", Fwindow_normal_size, Swindow_normal_size, 0, 2, 0,
(Lisp_Object window, Lisp_Object horizontal)
{
if (NILP (horizontal))
- return WVAR (decode_any_window (window), normal_lines);
+ return WGET (decode_any_window (window), normal_lines);
else
- return WVAR (decode_any_window (window), normal_cols);
+ return WGET (decode_any_window (window), normal_cols);
}
DEFUN ("window-new-normal", Fwindow_new_normal, Swindow_new_normal, 0, 1, 0,
If WINDOW is omitted or nil, it defaults to the selected window. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), new_normal);
+ return WGET (decode_any_window (window), new_normal);
}
DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
If WINDOW is omitted or nil, it defaults to the selected window. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), left_col);
+ return WGET (decode_any_window (window), left_col);
}
DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
If WINDOW is omitted or nil, it defaults to the selected window. */)
(Lisp_Object window)
{
- return WVAR (decode_any_window (window), top_line);
+ return WGET (decode_any_window (window), top_line);
}
/* Return the number of lines of W's body. Don't count any mode or
static int
window_body_lines (struct window *w)
{
- int height = XFASTINT (WVAR (w, total_lines));
+ int height = XFASTINT (WGET (w, total_lines));
if (!MINI_WINDOW_P (w))
{
window_body_cols (struct window *w)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
- int width = XINT (WVAR (w, total_cols));
+ int width = XINT (WGET (w, total_cols));
if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
/* Scroll bars occupy a few columns. */
/* Prevent redisplay shortcuts when changing the hscroll. */
if (w->hscroll != new_hscroll)
- XBUFFER (WVAR (w, buffer))->prevent_redisplay_optimizations_p = 1;
+ XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
w->hscroll = new_hscroll;
return make_number (new_hscroll);
See `set-window-redisplay-end-trigger' for more information. */)
(Lisp_Object window)
{
- return WVAR (decode_window (window), redisplay_end_trigger);
+ return WGET (decode_window (window), redisplay_end_trigger);
}
DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
Afterwards the end-trigger value is reset to nil. */)
(register Lisp_Object window, Lisp_Object value)
{
- register struct window *w;
-
- w = decode_window (window);
- WVAR (w, redisplay_end_trigger) = value;
- return value;
+ return WSET (decode_window (window), redisplay_end_trigger, value);
}
DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
static void
calc_absolute_offset (struct window *w, int *add_x, int *add_y)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
*add_y = f->top_pos;
#ifdef FRAME_MENUBAR_HEIGHT
*add_y += FRAME_MENUBAR_HEIGHT (f);
CHECK_LIVE_WINDOW (window);
w = XWINDOW (window);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
CHECK_CONS (coordinates);
lx = Fcar (coordinates);
ly = Fcdr (coordinates);
register struct window *w = decode_window (window);
if (w == XWINDOW (selected_window)
- && current_buffer == XBUFFER (WVAR (w, buffer)))
+ && current_buffer == XBUFFER (WGET (w, buffer)))
return Fpoint ();
- return Fmarker_position (WVAR (w, pointm));
+ return Fmarker_position (WGET (w, pointm));
}
DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
This is updated by redisplay or by calling `set-window-start'. */)
(Lisp_Object window)
{
- return Fmarker_position (WVAR (decode_window (window), start));
+ return Fmarker_position (WGET (decode_window (window), start));
}
/* This is text temporarily removed from the doc string below.
Lisp_Object buf;
struct buffer *b;
- buf = WVAR (w, buffer);
+ buf = WGET (w, buffer);
CHECK_BUFFER (buf);
b = XBUFFER (buf);
The user can compute it with vertical-motion if he wants to.
It would be nicer to do it automatically,
but that's so slow that it would probably bother people. */
- if (NILP (WVAR (w, window_end_valid)))
+ if (NILP (WGET (w, window_end_valid)))
return Qnil;
#endif
if (! NILP (update)
- && ! (! NILP (WVAR (w, window_end_valid))
+ && ! (! NILP (WGET (w, window_end_valid))
&& w->last_modified >= BUF_MODIFF (b)
&& w->last_overlay_modified >= BUF_OVERLAY_MODIFF (b))
&& !noninteractive)
`-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. */
- if (XMARKER (WVAR (w, start))->charpos < BEGV)
+ if (XMARKER (WGET (w, start))->charpos < BEGV)
SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
- else if (XMARKER (WVAR (w, start))->charpos > ZV)
+ else if (XMARKER (WGET (w, start))->charpos > ZV)
SET_TEXT_POS (startp, ZV, ZV_BYTE);
else
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
itdata = bidi_shelve_cache ();
start_display (&it, w, startp);
set_buffer_internal (old_buffer);
}
else
- XSETINT (value, BUF_Z (b) - XFASTINT (WVAR (w, window_end_pos)));
+ XSETINT (value, BUF_Z (b) - XFASTINT (WGET (w, window_end_pos)));
return value;
}
CHECK_NUMBER_COERCE_MARKER (pos);
if (w == XWINDOW (selected_window)
- && XBUFFER (WVAR (w, buffer)) == current_buffer)
+ && XBUFFER (WGET (w, buffer)) == current_buffer)
Fgoto_char (pos);
else
- set_marker_restricted (WVAR (w, pointm), pos, WVAR (w, buffer));
+ set_marker_restricted (WGET (w, pointm), pos, WGET (w, buffer));
/* We have to make sure that redisplay updates the window to show
the new value of point. */
register struct window *w = decode_window (window);
CHECK_NUMBER_COERCE_MARKER (pos);
- set_marker_restricted (WVAR (w, start), pos, WVAR (w, buffer));
+ set_marker_restricted (WGET (w, start), pos, WGET (w, buffer));
/* this is not right, but much easier than doing what is right. */
w->start_at_line_beg = 0;
if (NILP (noforce))
int x, y;
w = decode_window (window);
- buf = XBUFFER (WVAR (w, buffer));
- SET_TEXT_POS_FROM_MARKER (top, WVAR (w, start));
+ buf = XBUFFER (WGET (w, buffer));
+ SET_TEXT_POS_FROM_MARKER (top, WGET (w, start));
if (EQ (pos, Qt))
posint = -1;
else if (w == XWINDOW (selected_window))
posint = PT;
else
- posint = XMARKER (WVAR (w, pointm))->charpos;
+ posint = XMARKER (WGET (w, pointm))->charpos;
/* If position is above window start or outside buffer boundaries,
or if window start is out of range, position is not visible. */
if (noninteractive || w->pseudo_window_p)
return Qnil;
- CHECK_BUFFER (WVAR (w, buffer));
- b = XBUFFER (WVAR (w, buffer));
+ CHECK_BUFFER (WGET (w, buffer));
+ b = XBUFFER (WGET (w, buffer));
/* Fail if current matrix is not up-to-date. */
- if (NILP (WVAR (w, window_end_valid))
+ if (NILP (WGET (w, window_end_valid))
|| current_buffer->clip_changed
|| current_buffer->prevent_redisplay_optimizations_p
|| w->last_modified < BUF_MODIFF (b)
is the value returned by `window-dedicated-p' is t. */)
(Lisp_Object window)
{
- return WVAR (decode_window (window), dedicated);
+ return WGET (decode_window (window), dedicated);
}
DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
window, it also makes sure that the window is no more dedicated. */)
(Lisp_Object window, Lisp_Object flag)
{
- register struct window *w = decode_window (window);
-
- WVAR (w, dedicated) = flag;
- return WVAR (w, dedicated);
+ return WSET (decode_window (window), dedicated, flag);
}
DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
window for that buffer, and POS is a window-specific point value. */)
(Lisp_Object window)
{
- return WVAR (decode_window (window), prev_buffers);
+ return WGET (decode_window (window), prev_buffers);
}
DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
window for that buffer, and POS is a window-specific point value. */)
(Lisp_Object window, Lisp_Object prev_buffers)
{
- return WVAR (decode_window (window), prev_buffers) = prev_buffers;
+ return WSET (decode_window (window), prev_buffers, prev_buffers);
}
DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
WINDOW must be a live window and defaults to the selected one. */)
(Lisp_Object window)
{
- return WVAR (decode_window (window), next_buffers);
+ return WGET (decode_window (window), next_buffers);
}
DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
NEXT-BUFFERS should be a list of buffers. */)
(Lisp_Object window, Lisp_Object next_buffers)
{
- return WVAR (decode_window (window), next_buffers) = next_buffers;
+ return WSET (decode_window (window), next_buffers, next_buffers);
}
DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
elements of the form (PARAMETER . VALUE). */)
(Lisp_Object window)
{
- return Fcopy_alist (WVAR (decode_any_window (window), window_parameters));
+ return Fcopy_alist (WGET (decode_any_window (window), window_parameters));
}
DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
{
Lisp_Object result;
- result = Fassq (parameter, WVAR (decode_any_window (window),
+ result = Fassq (parameter, WGET (decode_any_window (window),
window_parameters));
return CDR_SAFE (result);
}
register struct window *w = decode_any_window (window);
Lisp_Object old_alist_elt;
- old_alist_elt = Fassq (parameter, WVAR (w, window_parameters));
+ old_alist_elt = Fassq (parameter, WGET (w, window_parameters));
if (NILP (old_alist_elt))
- WVAR (w, window_parameters)
- = Fcons (Fcons (parameter, value), WVAR (w, window_parameters));
+ WSET (w, window_parameters,
+ Fcons (Fcons (parameter, value), WGET (w, window_parameters)));
else
Fsetcdr (old_alist_elt, value);
return value;
WINDOW defaults to the selected window. */)
(Lisp_Object window)
{
- return WVAR (decode_window (window), display_table);
+ return WGET (decode_window (window), display_table);
}
/* Get the display table for use on window W. This is either W's
{
struct Lisp_Char_Table *dp = NULL;
- if (DISP_TABLE_P (WVAR (w, display_table)))
- dp = XCHAR_TABLE (WVAR (w, display_table));
- else if (BUFFERP (WVAR (w, buffer)))
+ if (DISP_TABLE_P (WGET (w, display_table)))
+ dp = XCHAR_TABLE (WGET (w, display_table));
+ else if (BUFFERP (WGET (w, buffer)))
{
- struct buffer *b = XBUFFER (WVAR (w, buffer));
+ struct buffer *b = XBUFFER (WGET (w, buffer));
if (DISP_TABLE_P (BVAR (b, display_table)))
dp = XCHAR_TABLE (BVAR (b, display_table));
doc: /* Set WINDOW's display-table to TABLE. */)
(register Lisp_Object window, Lisp_Object table)
{
- register struct window *w;
-
- w = decode_window (window);
- WVAR (w, display_table) = table;
- return table;
+ return WSET (decode_window (window), display_table, table);
}
\f
/* Record info on buffer window W is displaying
Lisp_Object buf;
struct buffer *b;
- buf = WVAR (w, buffer);
+ buf = WGET (w, buffer);
b = XBUFFER (buf);
- if (b != XMARKER (WVAR (w, pointm))->buffer)
+ if (b != XMARKER (WGET (w, pointm))->buffer)
abort ();
#if 0
if (w == XWINDOW (selected_window)
- || ! EQ (buf, WVAR (XWINDOW (selected_window), buffer)))
+ || ! EQ (buf, WGET (XWINDOW (selected_window), buffer)))
/* Do this except when the selected window's buffer
is being removed from some other window. */
#endif
selected window, while last_window_start reflects another
window which was recently showing the same buffer.
Some people might say that might be a good thing. Let's see. */
- b->last_window_start = marker_position (WVAR (w, start));
+ b->last_window_start = marker_position (WGET (w, start));
/* Point in the selected window's buffer
is actually stored in that buffer, and the window's pointm isn't used.
So don't clobber point in that buffer. */
- if (! EQ (buf, WVAR (XWINDOW (selected_window), buffer))
+ if (! EQ (buf, WGET (XWINDOW (selected_window), buffer))
/* This line helps to fix Horsley's testbug.el bug. */
&& !(WINDOWP (BVAR (b, last_selected_window))
&& w != XWINDOW (BVAR (b, last_selected_window))
- && EQ (buf, WVAR (XWINDOW (BVAR (b, last_selected_window)), buffer))))
+ && EQ (buf, WGET (XWINDOW (BVAR (b, last_selected_window)), buffer))))
temp_set_point_both (b,
clip_to_bounds (BUF_BEGV (b),
- XMARKER (WVAR (w, pointm))->charpos,
+ XMARKER (WGET (w, pointm))->charpos,
BUF_ZV (b)),
clip_to_bounds (BUF_BEGV_BYTE (b),
- marker_byte_position (WVAR (w, pointm)),
+ marker_byte_position (WGET (w, pointm)),
BUF_ZV_BYTE (b)));
if (WINDOWP (BVAR (b, last_selected_window))
/* If OLD is its frame's root window, then NEW is the new
root window for that frame. */
- if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (WVAR (o, frame)))))
- FSET (XFRAME (WVAR (o, frame)), root_window, new);
-
- if (setflag)
- {
- WVAR (n, left_col) = WVAR (o, left_col);
- WVAR (n, top_line) = WVAR (o, top_line);
- WVAR (n, total_cols) = WVAR (o, total_cols);
- WVAR (n, total_lines) = WVAR (o, total_lines);
- WVAR (n, normal_cols) = WVAR (o, normal_cols);
- WVAR (o, normal_cols) = make_float (1.0);
- WVAR (n, normal_lines) = WVAR (o, normal_lines);
- WVAR (o, normal_lines) = make_float (1.0);
+ if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (WGET (o, frame)))))
+ FSET (XFRAME (WGET (o, frame)), root_window, new);
+
+ if (setflag)
+ {
+ WSET (n, left_col, WGET (o, left_col));
+ WSET (n, top_line, WGET (o, top_line));
+ WSET (n, total_cols, WGET (o, total_cols));
+ WSET (n, total_lines, WGET (o, total_lines));
+ WSET (n, normal_cols, WGET (o, normal_cols));
+ WSET (o, normal_cols, make_float (1.0));
+ WSET (n, normal_lines, WGET (o, normal_lines));
+ WSET (o, normal_lines, make_float (1.0));
n->desired_matrix = n->current_matrix = 0;
n->vscroll = 0;
memset (&n->cursor, 0, sizeof (n->cursor));
n->phys_cursor_width = -1;
n->must_be_updated_p = 0;
n->pseudo_window_p = 0;
- XSETFASTINT (WVAR (n, window_end_vpos), 0);
- XSETFASTINT (WVAR (n, window_end_pos), 0);
- WVAR (n, window_end_valid) = Qnil;
+ WSET (n, window_end_vpos, make_number (0));
+ WSET (n, window_end_pos, make_number (0));
+ WSET (n, window_end_valid, Qnil);
n->frozen_window_start_p = 0;
}
- WVAR (n, next) = tem = WVAR (o, next);
+ tem = WGET (o, next);
+ WSET (n, next, tem);
if (!NILP (tem))
- WVAR (XWINDOW (tem), prev) = new;
+ WSET (XWINDOW (tem), prev, new);
- WVAR (n, prev) = tem = WVAR (o, prev);
+ tem = WGET (o, prev);
+ WSET (n, prev, tem);
if (!NILP (tem))
- WVAR (XWINDOW (tem), next) = new;
+ WSET (XWINDOW (tem), next, new);
- WVAR (n, parent) = tem = WVAR (o, parent);
+ tem = WGET (o, parent);
+ WSET (n, parent, tem);
if (!NILP (tem))
{
- if (EQ (WVAR (XWINDOW (tem), vchild), old))
- WVAR (XWINDOW (tem), vchild) = new;
- if (EQ (WVAR (XWINDOW (tem), hchild), old))
- WVAR (XWINDOW (tem), hchild) = new;
+ if (EQ (WGET (XWINDOW (tem), vchild), old))
+ WSET (XWINDOW (tem), vchild, new);
+ if (EQ (WGET (XWINDOW (tem), hchild), old))
+ WSET (XWINDOW (tem), hchild, new);
}
}
int horflag;
w = XWINDOW (window);
- parent = WVAR (w, parent);
- if (!NILP (parent) && NILP (WVAR (w, combination_limit)))
+ parent = WGET (w, parent);
+ if (!NILP (parent) && NILP (WGET (w, combination_limit)))
{
p = XWINDOW (parent);
- if (((!NILP (WVAR (p, vchild)) && !NILP (WVAR (w, vchild)))
- || (!NILP (WVAR (p, hchild)) && !NILP (WVAR (w, hchild)))))
+ if (((!NILP (WGET (p, vchild)) && !NILP (WGET (w, vchild)))
+ || (!NILP (WGET (p, hchild)) && !NILP (WGET (w, hchild)))))
/* WINDOW and PARENT are both either a vertical or a horizontal
combination. */
{
- horflag = NILP (WVAR (w, vchild));
- child = horflag ? WVAR (w, hchild) : WVAR (w, vchild);
+ horflag = NILP (WGET (w, vchild));
+ child = horflag ? WGET (w, hchild) : WGET (w, vchild);
c = XWINDOW (child);
/* Splice WINDOW's children into its parent's children and
assign new normal sizes. */
- if (NILP (WVAR (w, prev)))
+ if (NILP (WGET (w, prev)))
if (horflag)
- WVAR (p, hchild) = child;
+ WSET (p, hchild, child);
else
- WVAR (p, vchild) = child;
+ WSET (p, vchild, child);
else
{
- WVAR (c, prev) = WVAR (w, prev);
- WVAR (XWINDOW (WVAR (w, prev)), next) = child;
+ WSET (c, prev, WGET (w, prev));
+ WSET (XWINDOW (WGET (w, prev)), next, child);
}
while (c)
{
- WVAR (c, parent) = parent;
+ WSET (c, parent, parent);
if (horflag)
- WVAR (c, normal_cols)
- = make_float (XFLOATINT (WVAR (c, total_cols))
- / XFLOATINT (WVAR (p, total_cols)));
+ WSET (c, normal_cols,
+ make_float (XFLOATINT (WGET (c, total_cols))
+ / XFLOATINT (WGET (p, total_cols))));
else
- WVAR (c, normal_lines)
- = make_float (XFLOATINT (WVAR (c, total_lines))
- / XFLOATINT (WVAR (p, total_lines)));
+ WSET (c, normal_lines,
+ make_float (XFLOATINT (WGET (c, total_lines))
+ / XFLOATINT (WGET (p, total_lines))));
- if (NILP (WVAR (c, next)))
+ if (NILP (WGET (c, next)))
{
- if (!NILP (WVAR (w, next)))
+ if (!NILP (WGET (w, next)))
{
- WVAR (c, next) = WVAR (w, next);
- WVAR (XWINDOW (WVAR (c, next)), prev) = child;
+ WSET (c, next, WGET (w, next));
+ WSET (XWINDOW (WGET (c, next)), prev, child);
}
c = 0;
}
else
{
- child = WVAR (c, next);
+ child = WGET (c, next);
c = XWINDOW (child);
}
}
/* WINDOW can be deleted now. */
- WVAR (w, vchild) = WVAR (w, hchild) = Qnil;
+ WSET (w, vchild, Qnil);
+ WSET (w, hchild, Qnil);
}
}
}
candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf, Lisp_Object all_frames)
{
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int candidate_p = 1;
- if (!BUFFERP (WVAR (w, buffer)))
+ if (!BUFFERP (WGET (w, buffer)))
candidate_p = 0;
else if (MINI_WINDOW_P (w)
&& (EQ (minibuf, Qlambda)
else if (NILP (all_frames))
{
eassert (WINDOWP (owindow));
- candidate_p = EQ (WVAR (w, frame), WVAR (XWINDOW (owindow), frame));
+ candidate_p = EQ (WGET (w, frame), WGET (XWINDOW (owindow), frame));
}
else if (EQ (all_frames, Qvisible))
{
FRAME_SAMPLE_VISIBILITY (f);
candidate_p = FRAME_VISIBLE_P (f)
- && (FRAME_TERMINAL (XFRAME (WVAR (w, frame)))
+ && (FRAME_TERMINAL (XFRAME (WGET (w, frame)))
== FRAME_TERMINAL (XFRAME (selected_frame)));
}
&& !f->output_data.x->has_been_visible)
#endif
)
- && (FRAME_TERMINAL (XFRAME (WVAR (w, frame)))
+ && (FRAME_TERMINAL (XFRAME (WGET (w, frame)))
== FRAME_TERMINAL (XFRAME (selected_frame)));
}
else if (WINDOWP (all_frames))
candidate_p = (EQ (FRAME_MINIBUF_WINDOW (f), all_frames)
- || EQ (WVAR (XWINDOW (all_frames), frame), WVAR (w, frame))
- || EQ (WVAR (XWINDOW (all_frames), frame), FRAME_FOCUS_FRAME (f)));
+ || EQ (WGET (XWINDOW (all_frames), frame), WGET (w, frame))
+ || EQ (WGET (XWINDOW (all_frames), frame), FRAME_FOCUS_FRAME (f)));
else if (FRAMEP (all_frames))
- candidate_p = EQ (all_frames, WVAR (w, frame));
+ candidate_p = EQ (all_frames, WGET (w, frame));
return candidate_p;
}
if (NILP (*all_frames))
*all_frames
= (!EQ (*minibuf, Qlambda)
- ? FRAME_MINIBUF_WINDOW (XFRAME (WVAR (XWINDOW (*window), frame)))
+ ? FRAME_MINIBUF_WINDOW (XFRAME (WGET (XWINDOW (*window), frame)))
: Qnil);
else if (EQ (*all_frames, Qvisible))
;
/* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
return the first window on the frame. */
if (FRAMEP (all_frames)
- && !EQ (all_frames, WVAR (XWINDOW (window), frame)))
+ && !EQ (all_frames, WGET (XWINDOW (window), frame)))
return Fframe_first_window (all_frames);
if (next_p)
if (NILP (frame))
frame = selected_frame;
- if (!EQ (frame, WVAR (XWINDOW (window), frame)))
+ if (!EQ (frame, WGET (XWINDOW (window), frame)))
error ("Window is on a different frame");
return window_list_1 (window, minibuf, frame);
switch (type)
{
case GET_BUFFER_WINDOW:
- if (EQ (WVAR (w, buffer), obj)
+ if (EQ (WGET (w, buffer), obj)
/* Don't find any minibuffer window except the one that
is currently in use. */
&& (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))
if (EQ (window, selected_window))
/* Preferably return the selected window. */
RETURN_UNGCPRO (window);
- else if (EQ (WVAR (XWINDOW (window), frame), selected_frame)
+ else if (EQ (WGET (XWINDOW (window), frame), selected_frame)
&& !frame_best_window_flag)
/* Prefer windows on the current frame (but don't
choose another one if we have one already). */
case REPLACE_BUFFER_IN_WINDOWS_SAFELY:
/* We could simply check whether the buffer shown by window
is live, and show another buffer in case it isn't. */
- if (EQ (WVAR (w, buffer), obj))
+ if (EQ (WGET (w, buffer), obj))
{
/* Undedicate WINDOW. */
- WVAR (w, dedicated) = Qnil;
+ WSET (w, dedicated, Qnil);
/* Make WINDOW show the buffer returned by
other_buffer_safely, don't run any hooks. */
set_window_buffer
- (window, other_buffer_safely (WVAR (w, buffer)), 0, 0);
+ (window, other_buffer_safely (WGET (w, buffer)), 0, 0);
/* If WINDOW is the selected window, make its buffer
current. But do so only if the window shows the
current buffer (Bug#6454). */
if (EQ (window, selected_window)
- && XBUFFER (WVAR (w, buffer)) == current_buffer)
- Fset_buffer (WVAR (w, buffer));
+ && XBUFFER (WGET (w, buffer)) == current_buffer)
+ Fset_buffer (WGET (w, buffer));
}
break;
case REDISPLAY_BUFFER_WINDOWS:
- if (EQ (WVAR (w, buffer), obj))
+ if (EQ (WGET (w, buffer), obj))
{
mark_window_display_accurate (window, 0);
w->update_mode_line = 1;
/* Check for a window that has a killed buffer. */
case CHECK_ALL_WINDOWS:
- if (! NILP (WVAR (w, buffer))
- && NILP (BVAR (XBUFFER (WVAR (w, buffer)), name)))
+ if (! NILP (WGET (w, buffer))
+ && NILP (BVAR (XBUFFER (WGET (w, buffer)), name)))
abort ();
break;
w = decode_any_window (window);
XSETWINDOW (window, w);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
if (NILP (root))
/* ROOT is the frame's root window. */
/* ROOT must be an ancestor of WINDOW. */
{
r = decode_any_window (root);
- pwindow = WVAR (XWINDOW (window), parent);
+ pwindow = WGET (XWINDOW (window), parent);
while (!NILP (pwindow))
if (EQ (pwindow, root))
break;
else
- pwindow = WVAR (XWINDOW (pwindow), parent);
+ pwindow = WGET (XWINDOW (pwindow), parent);
if (!EQ (pwindow, root))
error ("Specified root is not an ancestor of specified window");
}
else if (MINI_WINDOW_P (w)) /* && top > 0) */
error ("Can't expand minibuffer to full frame");
- if (!NILP (WVAR (w, buffer)))
+ if (!NILP (WGET (w, buffer)))
{
- startpos = marker_position (WVAR (w, start));
+ startpos = marker_position (WGET (w, start));
top = WINDOW_TOP_EDGE_LINE (w)
- FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
/* Make sure WINDOW is the frame's selected window. */
if (!EQ (window, FRAME_SELECTED_WINDOW (f)))
{
- if (EQ (selected_frame, WVAR (w, frame)))
+ if (EQ (selected_frame, WGET (w, frame)))
Fselect_window (window, Qnil);
else
FSET (f, selected_window, window);
{
pwindow = swindow;
while (!NILP (pwindow) && !EQ (window, pwindow))
- pwindow = WVAR (XWINDOW (pwindow), parent);
+ pwindow = WGET (XWINDOW (pwindow), parent);
if (EQ (window, pwindow))
/* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
if (!EQ (swindow, FRAME_SELECTED_WINDOW (f)))
{
- if (EQ (selected_frame, WVAR (w, frame)))
+ if (EQ (selected_frame, WGET (w, frame)))
Fselect_window (swindow, Qnil);
else
FSET (f, selected_window, swindow);
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
resize_failed = 0;
- if (NILP (WVAR (w, buffer)))
+ if (NILP (WGET (w, buffer)))
{
/* Resize child windows vertically. */
- XSETINT (delta, XINT (WVAR (r, total_lines))
- - XINT (WVAR (w, total_lines)));
- WVAR (w, top_line) = WVAR (r, top_line);
+ XSETINT (delta, XINT (WGET (r, total_lines))
+ - XINT (WGET (w, total_lines)));
+ WSET (w, top_line, WGET (r, top_line));
resize_root_window (window, delta, Qnil, Qnil);
if (window_resize_check (w, 0))
window_resize_apply (w, 0);
/* Resize child windows horizontally. */
if (!resize_failed)
{
- WVAR (w, left_col) = WVAR (r, left_col);
- XSETINT (delta, XINT (WVAR (r, total_cols))
- - XINT (WVAR (w, total_cols)));
- WVAR (w, left_col) = WVAR (r, left_col);
+ WSET (w, left_col, WGET (r, left_col));
+ XSETINT (delta, XINT (WGET (r, total_cols))
+ - XINT (WGET (w, total_cols)));
+ WSET (w, left_col, WGET (r, left_col));
resize_root_window (window, delta, Qt, Qnil);
if (window_resize_check (w, 1))
window_resize_apply (w, 1);
}
/* Cleanly unlink WINDOW from window-tree. */
- if (!NILP (WVAR (w, prev)))
+ if (!NILP (WGET (w, prev)))
/* Get SIBLING above (on the left of) WINDOW. */
{
- sibling = WVAR (w, prev);
+ sibling = WGET (w, prev);
s = XWINDOW (sibling);
- WVAR (s, next) = WVAR (w, next);
- if (!NILP (WVAR (s, next)))
- WVAR (XWINDOW (WVAR (s, next)), prev) = sibling;
+ WSET (s, next, WGET (w, next));
+ if (!NILP (WGET (s, next)))
+ WSET (XWINDOW (WGET (s, next)), prev, sibling);
}
else
/* Get SIBLING below (on the right of) WINDOW. */
{
- sibling = WVAR (w, next);
+ sibling = WGET (w, next);
s = XWINDOW (sibling);
- WVAR (s, prev) = Qnil;
- if (!NILP (WVAR (XWINDOW (WVAR (w, parent)), vchild)))
- WVAR (XWINDOW (WVAR (w, parent)), vchild) = sibling;
+ WSET (s, prev, Qnil);
+ if (!NILP (WGET (XWINDOW (WGET (w, parent)), vchild)))
+ WSET (XWINDOW (WGET (w, parent)), vchild, sibling);
else
- WVAR (XWINDOW (WVAR (w, parent)), hchild) = sibling;
+ WSET (XWINDOW (WGET (w, parent)), hchild, sibling);
}
/* Delete ROOT and all child windows of ROOT. */
- if (!NILP (WVAR (r, vchild)))
+ if (!NILP (WGET (r, vchild)))
{
- delete_all_child_windows (WVAR (r, vchild));
- WVAR (r, vchild) = Qnil;
+ delete_all_child_windows (WGET (r, vchild));
+ WSET (r, vchild, Qnil);
}
- else if (!NILP (WVAR (r, hchild)))
+ else if (!NILP (WGET (r, hchild)))
{
- delete_all_child_windows (WVAR (r, hchild));
- WVAR (r, hchild) = Qnil;
+ delete_all_child_windows (WGET (r, hchild));
+ WSET (r, hchild, Qnil);
}
replace_window (root, window, 1);
/* This must become SWINDOW anyway ....... */
- if (!NILP (WVAR (w, buffer)) && !resize_failed)
+ if (!NILP (WGET (w, buffer)) && !resize_failed)
{
/* Try to minimize scrolling, by setting the window start to the
point will cause the text at the old window start to be at the
when the display is not current, due to typeahead). */
new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
if (new_top != top
- && startpos >= BUF_BEGV (XBUFFER (WVAR (w, buffer)))
- && startpos <= BUF_ZV (XBUFFER (WVAR (w, buffer))))
+ && startpos >= BUF_BEGV (XBUFFER (WGET (w, buffer)))
+ && startpos <= BUF_ZV (XBUFFER (WGET (w, buffer))))
{
struct position pos;
struct buffer *obuf = current_buffer;
- Fset_buffer (WVAR (w, buffer));
+ Fset_buffer (WGET (w, buffer));
/* This computation used to temporarily move point, but that
can have unwanted side effects due to text properties. */
pos = *vmotion (startpos, -top, w);
- set_marker_both (WVAR (w, start), WVAR (w, buffer), pos.bufpos, pos.bytepos);
- WVAR (w, window_end_valid) = Qnil;
+ set_marker_both (WGET (w, start), WGET (w, buffer), pos.bufpos, pos.bytepos);
+ WSET (w, window_end_valid, Qnil);
w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
|| FETCH_BYTE (pos.bytepos - 1) == '\n');
/* We need to do this, so that the window-scroll-functions
if (WINDOW_RIGHT_MARGIN_COLS (w) > 0)
{
if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
- WVAR (w, left_margin_cols) = WVAR (w, right_margin_cols)
- = make_number (margin_cols/2);
+ {
+ WSET (w, left_margin_cols, make_number (margin_cols / 2));
+ WSET (w, right_margin_cols, make_number (margin_cols / 2));
+ }
else
- WVAR (w, right_margin_cols) = make_number (margin_cols);
+ WSET (w, right_margin_cols, make_number (margin_cols));
}
else
- WVAR (w, left_margin_cols) = make_number (margin_cols);
+ WSET (w, left_margin_cols, make_number (margin_cols));
return 1;
}
\f
struct window *w = XWINDOW (window);
struct buffer *b = XBUFFER (buffer);
ptrdiff_t count = SPECPDL_INDEX ();
- int samebuf = EQ (buffer, WVAR (w, buffer));
+ int samebuf = EQ (buffer, WGET (w, buffer));
- WVAR (w, buffer) = buffer;
+ WSET (w, buffer, buffer);
if (EQ (window, selected_window))
BVAR (b, last_selected_window) = window;
XSETINT (BVAR (b, display_count), XINT (BVAR (b, display_count)) + 1);
BVAR (b, display_time) = Fcurrent_time ();
- XSETFASTINT (WVAR (w, window_end_pos), 0);
- XSETFASTINT (WVAR (w, window_end_vpos), 0);
+ WSET (w, window_end_pos, make_number (0));
+ WSET (w, window_end_vpos, make_number (0));
memset (&w->last_cursor, 0, sizeof w->last_cursor);
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
if (!(keep_margins_p && samebuf))
{ /* If we're not actually changing the buffer, don't reset hscroll and
vscroll. This case happens for example when called from
whenever we resize the frame. */
w->hscroll = w->min_hscroll = 0;
w->vscroll = 0;
- set_marker_both (WVAR (w, pointm), buffer, BUF_PT (b), BUF_PT_BYTE (b));
- set_marker_restricted (WVAR (w, start),
+ set_marker_both (WGET (w, pointm), buffer, BUF_PT (b), BUF_PT_BYTE (b));
+ set_marker_restricted (WGET (w, start),
make_number (b->last_window_start),
buffer);
w->start_at_line_beg = 0;
Fset_buffer (buffer);
}
- XMARKER (WVAR (w, pointm))->insertion_type = !NILP (Vwindow_point_insertion_type);
+ XMARKER (WGET (w, pointm))->insertion_type = !NILP (Vwindow_point_insertion_type);
if (!keep_margins_p)
{
/* This may call adjust_window_margins three times, so
temporarily disable window margins. */
- Lisp_Object save_left = WVAR (w, left_margin_cols);
- Lisp_Object save_right = WVAR (w, right_margin_cols);
+ Lisp_Object save_left = WGET (w, left_margin_cols);
+ Lisp_Object save_right = WGET (w, right_margin_cols);
- WVAR (w, left_margin_cols) = WVAR (w, right_margin_cols) = Qnil;
+ WSET (w, left_margin_cols, Qnil);
+ WSET (w, right_margin_cols, Qnil);
Fset_window_fringes (window,
BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
BVAR (b, scroll_bar_width),
BVAR (b, vertical_scroll_bar_type), Qnil);
- WVAR (w, left_margin_cols) = save_left;
- WVAR (w, right_margin_cols) = save_right;
+ WSET (w, left_margin_cols, save_left);
+ WSET (w, right_margin_cols, save_right);
Fset_window_margins (window,
BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
{
if (! NILP (Vwindow_scroll_functions))
run_hook_with_args_2 (Qwindow_scroll_functions, window,
- Fmarker_position (WVAR (w, start)));
+ Fmarker_position (WGET (w, start)));
run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
}
if (NILP (BVAR (XBUFFER (buffer), name)))
error ("Attempt to display deleted buffer");
- tem = WVAR (w, buffer);
+ tem = WGET (w, buffer);
if (NILP (tem))
error ("Window is deleted");
else if (!EQ (tem, Qt))
{
if (!EQ (tem, buffer))
{
- if (EQ (WVAR (w, dedicated), Qt))
+ if (EQ (WGET (w, dedicated), Qt))
/* WINDOW is strongly dedicated to its buffer, signal an
error. */
error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
else
/* WINDOW is weakly dedicated to its buffer, reset
dedication. */
- WVAR (w, dedicated) = Qnil;
+ WSET (w, dedicated, Qnil);
call1 (Qrecord_window_buffer, window);
}
struct window *w = XWINDOW (object);
mark_window_display_accurate (object, 0);
w->update_mode_line = 1;
- if (BUFFERP (WVAR (w, buffer)))
- XBUFFER (WVAR (w, buffer))->prevent_redisplay_optimizations_p = 1;
+ if (BUFFERP (WGET (w, buffer)))
+ XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
++update_mode_lines;
return Qt;
}
{
window = display_buffer (buf, Qnil, Qnil);
- if (!EQ (WVAR (XWINDOW (window), frame), selected_frame))
+ if (!EQ (WGET (XWINDOW (window), frame), selected_frame))
Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
Vminibuf_scroll_window = window;
w = XWINDOW (window);
w->hscroll = 0;
w->min_hscroll = 0;
- set_marker_restricted_both (WVAR (w, start), buf, BEG, BEG);
- set_marker_restricted_both (WVAR (w, pointm), buf, BEG, BEG);
+ set_marker_restricted_both (WGET (w, start), buf, BEG, BEG);
+ set_marker_restricted_both (WGET (w, pointm), buf, BEG, BEG);
/* Run temp-buffer-show-hook, with the chosen window selected
and its buffer current. */
record_unwind_protect (Fset_buffer, prev_buffer);
record_unwind_protect (select_window_norecord, prev_window);
Fselect_window (window, Qt);
- Fset_buffer (WVAR (w, buffer));
+ Fset_buffer (WGET (w, buffer));
Frun_hooks (1, &Qtemp_buffer_show_hook);
unbind_to (count, Qnil);
}
replace_window (window, parent, 1);
- WVAR (o, next) = Qnil;
- WVAR (o, prev) = Qnil;
- WVAR (o, parent) = parent;
+ WSET (o, next, Qnil);
+ WSET (o, prev, Qnil);
+ WSET (o, parent, parent);
- WVAR (p, hchild) = horflag ? window : Qnil;
- WVAR (p, vchild) = horflag ? Qnil : window;
- WVAR (p, start) = Qnil;
- WVAR (p, pointm) = Qnil;
- WVAR (p, buffer) = Qnil;
- WVAR (p, combination_limit) = Qnil;
- WVAR (p, window_parameters) = Qnil;
+ WSET (p, hchild, horflag ? window : Qnil);
+ WSET (p, vchild, horflag ? Qnil : window);
+ WSET (p, start, Qnil);
+ WSET (p, pointm, Qnil);
+ WSET (p, buffer, Qnil);
+ WSET (p, combination_limit, Qnil);
+ WSET (p, window_parameters, Qnil);
}
/* Make new window from scratch. */
w = allocate_window ();
/* Initialize Lisp data. Note that allocate_window initializes all
Lisp data to nil, so do it only for slots which should not be nil. */
- XSETFASTINT (WVAR (w, left_col), 0);
- XSETFASTINT (WVAR (w, top_line), 0);
- XSETFASTINT (WVAR (w, total_lines), 0);
- XSETFASTINT (WVAR (w, total_cols), 0);
- WVAR (w, normal_lines) = make_float (1.0);
- WVAR (w, normal_cols) = make_float (1.0);
- XSETFASTINT (WVAR (w, new_total), 0);
- XSETFASTINT (WVAR (w, new_normal), 0);
- WVAR (w, start) = Fmake_marker ();
- WVAR (w, pointm) = Fmake_marker ();
- WVAR (w, vertical_scroll_bar_type) = Qt;
- XSETFASTINT (WVAR (w, window_end_pos), 0);
- XSETFASTINT (WVAR (w, window_end_vpos), 0);
+ WSET (w, left_col, make_number (0));
+ WSET (w, top_line, make_number (0));
+ WSET (w, total_lines, make_number (0));
+ WSET (w, total_cols, make_number (0));
+ WSET (w, normal_lines, make_float (1.0));
+ WSET (w, normal_cols, make_float (1.0));
+ WSET (w, new_total, make_number (0));
+ WSET (w, new_normal, make_number (0));
+ WSET (w, start, Fmake_marker ());
+ WSET (w, pointm, Fmake_marker ());
+ WSET (w, vertical_scroll_bar_type, Qt);
+ WSET (w, window_end_pos, make_number (0));
+ WSET (w, window_end_vpos, make_number (0));
/* Initialize non-Lisp data. Note that allocate_window zeroes out all
non-Lisp data, so do it only for slots which should not be zero. */
CHECK_NUMBER (size);
if (NILP (add))
- XSETINT (WVAR (w, new_total), XINT (size));
+ WSET (w, new_total, size);
else
- XSETINT (WVAR (w, new_total), XINT (WVAR (w, new_total)) + XINT (size));
+ WSET (w, new_total, make_number (XINT (WGET (w, new_total)) + XINT (size)));
- return WVAR (w, new_total);
+ return WGET (w, new_total);
}
DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal, 1, 2, 0,
Note: This function does not operate on any child windows of WINDOW. */)
(Lisp_Object window, Lisp_Object size)
{
- struct window *w = decode_any_window (window);
-
- WVAR (w, new_normal) = size;
- return WVAR (w, new_normal);
+ return WSET (decode_any_window (window), new_normal, size);
}
/* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
{
struct window *c;
- if (!NILP (WVAR (w, vchild)))
+ if (!NILP (WGET (w, vchild)))
/* W is a vertical combination. */
{
- c = XWINDOW (WVAR (w, vchild));
+ c = XWINDOW (WGET (w, vchild));
if (horflag)
/* All child windows of W must have the same width as W. */
{
while (c)
{
- if ((XINT (WVAR (c, new_total)) != XINT (WVAR (w, new_total)))
+ if ((XINT (WGET (c, new_total)) != XINT (WGET (w, new_total)))
|| !window_resize_check (c, horflag))
return 0;
- c = NILP (WVAR (c, next)) ? 0 : XWINDOW (WVAR (c, next));
+ c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
}
return 1;
}
{
if (!window_resize_check (c, horflag))
return 0;
- sum_of_sizes = sum_of_sizes + XINT (WVAR (c, new_total));
- c = NILP (WVAR (c, next)) ? 0 : XWINDOW (WVAR (c, next));
+ sum_of_sizes = sum_of_sizes + XINT (WGET (c, new_total));
+ c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
}
- return (sum_of_sizes == XINT (WVAR (w, new_total)));
+ return (sum_of_sizes == XINT (WGET (w, new_total)));
}
}
- else if (!NILP (WVAR (w, hchild)))
+ else if (!NILP (WGET (w, hchild)))
/* W is a horizontal combination. */
{
- c = XWINDOW (WVAR (w, hchild));
+ c = XWINDOW (WGET (w, hchild));
if (horflag)
/* The sum of the widths of the child windows of W must equal W's
width. */
{
if (!window_resize_check (c, horflag))
return 0;
- sum_of_sizes = sum_of_sizes + XINT (WVAR (c, new_total));
- c = NILP (WVAR (c, next)) ? 0 : XWINDOW (WVAR (c, next));
+ sum_of_sizes = sum_of_sizes + XINT (WGET (c, new_total));
+ c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
}
- return (sum_of_sizes == XINT (WVAR (w, new_total)));
+ return (sum_of_sizes == XINT (WGET (w, new_total)));
}
else
/* All child windows of W must have the same height as W. */
{
while (c)
{
- if ((XINT (WVAR (c, new_total)) != XINT (WVAR (w, new_total)))
+ if ((XINT (WGET (c, new_total)) != XINT (WGET (w, new_total)))
|| !window_resize_check (c, horflag))
return 0;
- c = NILP (WVAR (c, next)) ? 0 : XWINDOW (WVAR (c, next));
+ c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
}
return 1;
}
/* A leaf window. Make sure it's not too small. The following
hardcodes the values of `window-safe-min-width' (2) and
`window-safe-min-height' (1) which are defined in window.el. */
- return XINT (WVAR (w, new_total)) >= (horflag ? 2 : 1);
+ return XINT (WGET (w, new_total)) >= (horflag ? 2 : 1);
}
/* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
parent window has been set *before*. */
if (horflag)
{
- WVAR (w, total_cols) = WVAR (w, new_total);
- if (NUMBERP (WVAR (w, new_normal)))
- WVAR (w, normal_cols) = WVAR (w, new_normal);
+ WSET (w, total_cols, WGET (w, new_total));
+ if (NUMBERP (WGET (w, new_normal)))
+ WSET (w, normal_cols, WGET (w, new_normal));
- pos = XINT (WVAR (w, left_col));
+ pos = XINT (WGET (w, left_col));
}
else
{
- WVAR (w, total_lines) = WVAR (w, new_total);
- if (NUMBERP (WVAR (w, new_normal)))
- WVAR (w, normal_lines) = WVAR (w, new_normal);
+ WSET (w, total_lines, WGET (w, new_total));
+ if (NUMBERP (WGET (w, new_normal)))
+ WSET (w, normal_lines, WGET (w, new_normal));
- pos = XINT (WVAR (w, top_line));
+ pos = XINT (WGET (w, top_line));
}
- if (!NILP (WVAR (w, vchild)))
+ if (!NILP (WGET (w, vchild)))
/* W is a vertical combination. */
{
- c = XWINDOW (WVAR (w, vchild));
+ c = XWINDOW (WGET (w, vchild));
while (c)
{
if (horflag)
- XSETFASTINT (WVAR (c, left_col), pos);
+ WSET (c, left_col, make_number (pos));
else
- XSETFASTINT (WVAR (c, top_line), pos);
+ WSET (c, top_line, make_number (pos));
window_resize_apply (c, horflag);
if (!horflag)
- pos = pos + XINT (WVAR (c, total_lines));
- c = NILP (WVAR (c, next)) ? 0 : XWINDOW (WVAR (c, next));
+ pos = pos + XINT (WGET (c, total_lines));
+ c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
}
}
- else if (!NILP (WVAR (w, hchild)))
+ else if (!NILP (WGET (w, hchild)))
/* W is a horizontal combination. */
{
- c = XWINDOW (WVAR (w, hchild));
+ c = XWINDOW (WGET (w, hchild));
while (c)
{
if (horflag)
- XSETFASTINT (WVAR (c, left_col), pos);
+ WSET (c, left_col, make_number (pos));
else
- XSETFASTINT (WVAR (c, top_line), pos);
+ WSET (c, top_line, make_number (pos));
window_resize_apply (c, horflag);
if (horflag)
- pos = pos + XINT (WVAR (c, total_cols));
- c = NILP (WVAR (c, next)) ? 0 : XWINDOW (WVAR (c, next));
+ pos = pos + XINT (WGET (c, total_cols));
+ c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
}
}
r = XWINDOW (FRAME_ROOT_WINDOW (f));
if (!window_resize_check (r, horflag)
- || ! EQ (WVAR (r, new_total),
- (horflag ? WVAR (r, total_cols) : WVAR (r, total_lines))))
+ || ! EQ (WGET (r, new_total),
+ (horflag ? WGET (r, total_cols) : WGET (r, total_lines))))
return Qnil;
BLOCK_INPUT;
- ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
? 1 : 0)));
- XSETFASTINT (WVAR (r, top_line), FRAME_TOP_MARGIN (f));
- if (NILP (WVAR (r, vchild)) && NILP (WVAR (r, hchild)))
+ WSET (r, top_line, make_number (FRAME_TOP_MARGIN (f)));
+ if (NILP (WGET (r, vchild)) && NILP (WGET (r, hchild)))
/* For a leaf root window just set the size. */
if (horflag)
- XSETFASTINT (WVAR (r, total_cols), new_size);
+ WSET (r, total_cols, make_number (new_size));
else
- XSETFASTINT (WVAR (r, total_lines), new_size);
+ WSET (r, total_lines, make_number (new_size));
else
{
/* old_size is the old size of the frame's root window. */
- int old_size = XFASTINT (horflag ? WVAR (r, total_cols)
- : WVAR (r, total_lines));
+ int old_size = XFASTINT (horflag ? WGET (r, total_cols)
+ : WGET (r, total_lines));
Lisp_Object delta;
XSETINT (delta, new_size - old_size);
/* Try a "normal" resize first. */
resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil);
if (window_resize_check (r, horflag)
- && new_size == XINT (WVAR (r, new_total)))
+ && new_size == XINT (WGET (r, new_total)))
window_resize_apply (r, horflag);
else
{
/* Try with "reasonable" minimum sizes next. */
resize_root_window (root, delta, horflag ? Qt : Qnil, Qt);
if (window_resize_check (r, horflag)
- && new_size == XINT (WVAR (r, new_total)))
+ && new_size == XINT (WGET (r, new_total)))
window_resize_apply (r, horflag);
else
{
/* Finally, try with "safe" minimum sizes. */
resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe);
if (window_resize_check (r, horflag)
- && new_size == XINT (WVAR (r, new_total)))
+ && new_size == XINT (WGET (r, new_total)))
window_resize_apply (r, horflag);
else
{
root = FGET (f, selected_window);
Fdelete_other_windows_internal (root, Qnil);
if (horflag)
- XSETFASTINT (WVAR (XWINDOW (root), total_cols), new_size);
+ WSET (XWINDOW (root), total_cols, make_number (new_size));
else
- XSETFASTINT (WVAR (XWINDOW (root), total_lines), new_size);
+ WSET (XWINDOW (root), total_lines, make_number (new_size));
}
}
}
{
m = XWINDOW (mini);
if (horflag)
- XSETFASTINT (WVAR (m, total_cols), size);
+ WSET (m, total_cols, make_number (size));
else
{
/* Are we sure we always want 1 line here? */
- XSETFASTINT (WVAR (m, total_lines), 1);
- XSETFASTINT (WVAR (m, top_line), XINT (WVAR (r, top_line))
- + XINT (WVAR (r, total_lines)));
+ WSET (m, total_lines, make_number (1));
+ WSET (m, top_line,
+ make_number (XINT (WGET (r, top_line)) + XINT (WGET (r, total_lines))));
}
}
}
parent, or OLD is ortho-combined. */
combination_limit =
!NILP (Vwindow_combination_limit)
- || NILP (WVAR (o, parent))
+ || NILP (WGET (o, parent))
|| NILP (horflag
- ? (WVAR (XWINDOW (WVAR (o, parent)), hchild))
- : (WVAR (XWINDOW (WVAR (o, parent)), vchild)));
+ ? (WGET (XWINDOW (WGET (o, parent)), hchild))
+ : (WGET (XWINDOW (WGET (o, parent)), vchild)));
/* We need a live reference window to initialize some parameters. */
if (WINDOW_LIVE_P (old))
/* `window-combination-resize' non-nil means try to resize OLD's siblings
proportionally. */
{
- p = XWINDOW (WVAR (o, parent));
+ p = XWINDOW (WGET (o, parent));
/* Temporarily pretend we split the parent window. */
- XSETINT (WVAR (p, new_total),
- XINT (horflag ? WVAR (p, total_cols) : WVAR (p, total_lines))
- - XINT (total_size));
+ WSET (p, new_total,
+ make_number (XINT (horflag ? WGET (p, total_cols) : WGET (p, total_lines))
+ - XINT (total_size)));
if (!window_resize_check (p, horflag))
error ("Window sizes don't fit");
else
/* Undo the temporary pretension. */
- WVAR (p, new_total)
- = horflag ? WVAR (p, total_cols) : WVAR (p, total_lines);
+ WSET (p, new_total,
+ horflag ? WGET (p, total_cols) : WGET (p, total_lines));
}
else
{
if (!window_resize_check (o, horflag))
error ("Resizing old window failed");
- else if (XINT (total_size) + XINT (WVAR (o, new_total))
- != XINT (horflag ? WVAR (o, total_cols) : WVAR (o, total_lines)))
+ else if (XINT (total_size) + XINT (WGET (o, new_total))
+ != XINT (horflag ? WGET (o, total_cols) : WGET (o, total_lines)))
error ("Sum of sizes of old and new window don't fit");
}
by make_parent_window and we need it below for assigning it to
p->new_normal. */
Lisp_Object new_normal
- = horflag ? WVAR (o, normal_cols) : WVAR (o, normal_lines);
+ = horflag ? WGET (o, normal_cols) : WGET (o, normal_lines);
make_parent_window (old, horflag);
- p = XWINDOW (WVAR (o, parent));
+ p = XWINDOW (WGET (o, parent));
/* Store value of `window-combination-limit' in new parent's
combination_limit slot. */
- WVAR (p, combination_limit) = Vwindow_combination_limit;
+ WSET (p, combination_limit, Vwindow_combination_limit);
/* These get applied below. */
- WVAR (p, new_total)
- = horflag ? WVAR (o, total_cols) : WVAR (o, total_lines);
- WVAR (p, new_normal) = new_normal;
+ WSET (p, new_total,
+ horflag ? WGET (o, total_cols) : WGET (o, total_lines));
+ WSET (p, new_normal, new_normal);
}
else
- p = XWINDOW (WVAR (o, parent));
+ p = XWINDOW (WGET (o, parent));
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
new = make_window ();
n = XWINDOW (new);
- WVAR (n, frame) = frame;
- WVAR (n, parent) = WVAR (o, parent);
- WVAR (n, vchild) = WVAR (n, hchild) = Qnil;
+ WSET (n, frame, frame);
+ WSET (n, parent, WGET (o, parent));
+ WSET (n, vchild, Qnil);
+ WSET (n, hchild, Qnil);
if (EQ (side, Qabove) || EQ (side, Qleft))
{
- WVAR (n, prev) = WVAR (o, prev);
- if (NILP (WVAR (n, prev)))
+ WSET (n, prev, WGET (o, prev));
+ if (NILP (WGET (n, prev)))
if (horflag)
- WVAR (p, hchild) = new;
+ WSET (p, hchild, new);
else
- WVAR (p, vchild) = new;
+ WSET (p, vchild, new);
else
- WVAR (XWINDOW (WVAR (n, prev)), next) = new;
- WVAR (n, next) = old;
- WVAR (o, prev) = new;
+ WSET (XWINDOW (WGET (n, prev)), next, new);
+ WSET (n, next, old);
+ WSET (o, prev, new);
}
else
{
- WVAR (n, next) = WVAR (o, next);
- if (!NILP (WVAR (n, next)))
- WVAR (XWINDOW (WVAR (n, next)), prev) = new;
- WVAR (n, prev) = old;
- WVAR (o, next) = new;
+ WSET (n, next, WGET (o, next));
+ if (!NILP (WGET (n, next)))
+ WSET (XWINDOW (WGET (n, next)), prev, new);
+ WSET (n, prev, old);
+ WSET (o, next, new);
}
- WVAR (n, buffer) = Qt;
- WVAR (n, window_end_valid) = Qnil;
+ WSET (n, buffer, Qt);
+ WSET (n, window_end_valid, Qnil);
memset (&n->last_cursor, 0, sizeof n->last_cursor);
/* Get special geometry settings from reference window. */
- WVAR (n, left_margin_cols) = WVAR (r, left_margin_cols);
- WVAR (n, right_margin_cols) = WVAR (r, right_margin_cols);
- WVAR (n, left_fringe_width) = WVAR (r, left_fringe_width);
- WVAR (n, right_fringe_width) = WVAR (r, right_fringe_width);
+ WSET (n, left_margin_cols, WGET (r, left_margin_cols));
+ WSET (n, right_margin_cols, WGET (r, right_margin_cols));
+ WSET (n, left_fringe_width, WGET (r, left_fringe_width));
+ WSET (n, right_fringe_width, WGET (r, right_fringe_width));
n->fringes_outside_margins = r->fringes_outside_margins;
- WVAR (n, scroll_bar_width) = WVAR (r, scroll_bar_width);
- WVAR (n, vertical_scroll_bar_type) = WVAR (r, vertical_scroll_bar_type);
+ WSET (n, scroll_bar_width, WGET (r, scroll_bar_width));
+ WSET (n, vertical_scroll_bar_type, WGET (r, vertical_scroll_bar_type));
/* Directly assign orthogonal coordinates and sizes. */
if (horflag)
{
- WVAR (n, top_line) = WVAR (o, top_line);
- WVAR (n, total_lines) = WVAR (o, total_lines);
+ WSET (n, top_line, WGET (o, top_line));
+ WSET (n, total_lines, WGET (o, total_lines));
}
else
{
- WVAR (n, left_col) = WVAR (o, left_col);
- WVAR (n, total_cols) = WVAR (o, total_cols);
+ WSET (n, left_col, WGET (o, left_col));
+ WSET (n, total_cols, WGET (o, total_cols));
}
/* Iso-coordinates and sizes are assigned by window_resize_apply,
get them ready here. */
- WVAR (n, new_total) = total_size;
- WVAR (n, new_normal) = normal_size;
+ WSET (n, new_total, total_size);
+ WSET (n, new_normal, normal_size);
BLOCK_INPUT;
window_resize_apply (p, horflag);
adjust_glyphs (f);
/* Set buffer of NEW to buffer of reference window. Don't run
any hooks. */
- set_window_buffer (new, WVAR (r, buffer), 0, 1);
+ set_window_buffer (new, WGET (r, buffer), 0, 1);
UNBLOCK_INPUT;
/* Maybe we should run the scroll functions in Elisp (which already
runs the configuration change hook). */
if (! NILP (Vwindow_scroll_functions))
run_hook_with_args_2 (Qwindow_scroll_functions, new,
- Fmarker_position (WVAR (n, start)));
+ Fmarker_position (WGET (n, start)));
/* Return NEW. */
return new;
}
w = decode_any_window (window);
XSETWINDOW (window, w);
- if (NILP (WVAR (w, buffer))
- && NILP (WVAR (w, hchild)) && NILP (WVAR (w, vchild)))
+ if (NILP (WGET (w, buffer))
+ && NILP (WGET (w, hchild)) && NILP (WGET (w, vchild)))
/* It's a no-op to delete an already deleted window. */
return Qnil;
- parent = WVAR (w, parent);
+ parent = WGET (w, parent);
if (NILP (parent))
/* Never delete a minibuffer or frame root window. */
error ("Attempt to delete minibuffer or sole ordinary window");
- else if (NILP (WVAR (w, prev)) && NILP (WVAR (w, next)))
+ else if (NILP (WGET (w, prev)) && NILP (WGET (w, next)))
/* Rather bow out here, this case should be handled on the Elisp
level. */
error ("Attempt to delete sole window of parent");
p = XWINDOW (parent);
- horflag = NILP (WVAR (p, vchild));
+ horflag = NILP (WGET (p, vchild));
frame = WINDOW_FRAME (w);
f = XFRAME (frame);
r = XWINDOW (root);
/* Unlink WINDOW from window tree. */
- if (NILP (WVAR (w, prev)))
+ if (NILP (WGET (w, prev)))
/* Get SIBLING below (on the right of) WINDOW. */
{
/* before_sibling 1 means WINDOW is the first child of its
parent and thus before the sibling. */
before_sibling = 1;
- sibling = WVAR (w, next);
+ sibling = WGET (w, next);
s = XWINDOW (sibling);
- WVAR (s, prev) = Qnil;
+ WSET (s, prev, Qnil);
if (horflag)
- WVAR (p, hchild) = sibling;
+ WSET (p, hchild, sibling);
else
- WVAR (p, vchild) = sibling;
+ WSET (p, vchild, sibling);
}
else
/* Get SIBLING above (on the left of) WINDOW. */
{
- sibling = WVAR (w, prev);
+ sibling = WGET (w, prev);
s = XWINDOW (sibling);
- WVAR (s, next) = WVAR (w, next);
- if (!NILP (WVAR (s, next)))
- WVAR (XWINDOW (WVAR (s, next)), prev) = sibling;
+ WSET (s, next, WGET (w, next));
+ if (!NILP (WGET (s, next)))
+ WSET (XWINDOW (WGET (s, next)), prev, sibling);
}
if (window_resize_check (r, horflag)
- && EQ (WVAR (r, new_total),
- (horflag ? WVAR (r, total_cols) : WVAR (r, total_lines))))
+ && EQ (WGET (r, new_total),
+ (horflag ? WGET (r, total_cols) : WGET (r, total_lines))))
/* We can delete WINDOW now. */
{
Vwindow_list = Qnil;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
- WVAR (w, next) = Qnil; /* Don't delete w->next too. */
+ WSET (w, next, Qnil); /* Don't delete w->next too. */
free_window_matrices (w);
- if (!NILP (WVAR (w, vchild)))
+ if (!NILP (WGET (w, vchild)))
{
- delete_all_child_windows (WVAR (w, vchild));
- WVAR (w, vchild) = Qnil;
+ delete_all_child_windows (WGET (w, vchild));
+ WSET (w, vchild, Qnil);
}
- else if (!NILP (WVAR (w, hchild)))
+ else if (!NILP (WGET (w, hchild)))
{
- delete_all_child_windows (WVAR (w, hchild));
- WVAR (w, hchild) = Qnil;
+ delete_all_child_windows (WGET (w, hchild));
+ WSET (w, hchild, Qnil);
}
- else if (!NILP (WVAR (w, buffer)))
+ else if (!NILP (WGET (w, buffer)))
{
unshow_buffer (w);
- unchain_marker (XMARKER (WVAR (w, pointm)));
- unchain_marker (XMARKER (WVAR (w, start)));
- WVAR (w, buffer) = Qnil;
+ unchain_marker (XMARKER (WGET (w, pointm)));
+ unchain_marker (XMARKER (WGET (w, start)));
+ WSET (w, buffer, Qnil);
}
- if (NILP (WVAR (s, prev)) && NILP (WVAR (s, next)))
+ if (NILP (WGET (s, prev)) && NILP (WGET (s, next)))
/* A matrjoshka where SIBLING has become the only child of
PARENT. */
{
replace_window (parent, sibling, 0);
/* Have SIBLING inherit the following three slot values from
PARENT (the combination_limit slot is not inherited). */
- WVAR (s, normal_cols) = WVAR (p, normal_cols);
- WVAR (s, normal_lines) = WVAR (p, normal_lines);
+ WSET (s, normal_cols, WGET (p, normal_cols));
+ WSET (s, normal_lines, WGET (p, normal_lines));
/* Mark PARENT as deleted. */
- WVAR (p, vchild) = WVAR (p, hchild) = Qnil;
+ WSET (p, vchild, Qnil);
+ WSET (p, hchild, Qnil);
/* Try to merge SIBLING into its new parent. */
recombine_windows (sibling);
}
/* Now look whether `get-mru-window' gets us something. */
mru_window = call1 (Qget_mru_window, frame);
if (WINDOW_LIVE_P (mru_window)
- && EQ (WVAR (XWINDOW (mru_window), frame), frame))
+ && EQ (WGET (XWINDOW (mru_window), frame), frame))
new_selected_window = mru_window;
/* If all ended up well, we now promote the mru window. */
{
if (before_sibling)
{
- WVAR (s, prev) = window;
+ WSET (s, prev, window);
if (horflag)
- WVAR (p, hchild) = window;
+ WSET (p, hchild, window);
else
- WVAR (p, vchild) = window;
+ WSET (p, vchild, window);
}
else
{
- WVAR (s, next) = window;
- if (!NILP (WVAR (w, next)))
- WVAR (XWINDOW (WVAR (w, next)), prev) = window;
+ WSET (s, next, window);
+ if (!NILP (WGET (w, next)))
+ WSET (XWINDOW (WGET (w, next)), prev, window);
}
error ("Deletion failed");
}
void
grow_mini_window (struct window *w, int delta)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct window *r;
Lisp_Object root, value;
window_resize_apply (r, 0);
/* Grow the mini-window. */
- XSETFASTINT (WVAR (w, top_line),
- XFASTINT (WVAR (r, top_line)) + XFASTINT (WVAR (r, total_lines)));
- XSETFASTINT (WVAR (w, total_lines), XFASTINT (WVAR (w, total_lines)) - XINT (value));
+ WSET (w, top_line,
+ make_number (XFASTINT (WGET (r, top_line)) + XFASTINT (WGET (r, total_lines))));
+ WSET (w, total_lines,
+ make_number (XFASTINT (WGET (w, total_lines)) - XINT (value)));
w->last_modified = 0;
w->last_overlay_modified = 0;
void
shrink_mini_window (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct window *r;
Lisp_Object root, value;
EMACS_INT size;
eassert (MINI_WINDOW_P (w));
- size = XINT (WVAR (w, total_lines));
+ size = XINT (WGET (w, total_lines));
if (size > 1)
{
root = FRAME_ROOT_WINDOW (f);
window_resize_apply (r, 0);
/* Shrink the mini-window. */
- XSETFASTINT (WVAR (w, top_line), XFASTINT (WVAR (r, top_line))
- + XFASTINT (WVAR (r, total_lines)));
- XSETFASTINT (WVAR (w, total_lines), 1);
+ WSET (w, top_line,
+ make_number (XFASTINT (WGET (r, top_line)) + XFASTINT (WGET (r, total_lines))));
+ WSET (w, total_lines, make_number (1));
w->last_modified = 0;
w->last_overlay_modified = 0;
int height;
CHECK_WINDOW (window);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
- if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (WVAR (w, frame))), window))
+ if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (WGET (w, frame))), window))
error ("Not a valid minibuffer window");
else if (FRAME_MINIBUF_ONLY_P (f))
error ("Cannot resize a minibuffer-only frame");
r = XWINDOW (FRAME_ROOT_WINDOW (f));
- height = XINT (WVAR (r, total_lines)) + XINT (WVAR (w, total_lines));
+ height = XINT (WGET (r, total_lines)) + XINT (WGET (w, total_lines));
if (window_resize_check (r, 0)
- && XINT (WVAR (w, new_total)) > 0
- && height == XINT (WVAR (r, new_total)) + XINT (WVAR (w, new_total)))
+ && XINT (WGET (w, new_total)) > 0
+ && height == XINT (WGET (r, new_total)) + XINT (WGET (w, new_total)))
{
BLOCK_INPUT;
window_resize_apply (r, 0);
- WVAR (w, total_lines) = WVAR (w, new_total);
- XSETFASTINT (WVAR (w, top_line),
- XINT (WVAR (r, top_line)) + XINT (WVAR (r, total_lines)));
+ WSET (w, total_lines, WGET (w, new_total));
+ WSET (w, top_line,
+ make_number (XINT (WGET (r, top_line)) + XINT (WGET (r, total_lines))));
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- mark_window_cursors_off (XWINDOW (WVAR (w, hchild)));
- else if (!NILP (WVAR (w, vchild)))
- mark_window_cursors_off (XWINDOW (WVAR (w, vchild)));
+ if (!NILP (WGET (w, hchild)))
+ mark_window_cursors_off (XWINDOW (WGET (w, hchild)));
+ else if (!NILP (WGET (w, vchild)))
+ mark_window_cursors_off (XWINDOW (WGET (w, vchild)));
else
w->phys_cursor_on_p = 0;
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
int
window_internal_height (struct window *w)
{
- int ht = XFASTINT (WVAR (w, total_lines));
+ int ht = XFASTINT (WGET (w, total_lines));
if (!MINI_WINDOW_P (w))
{
- if (!NILP (WVAR (w, parent))
- || !NILP (WVAR (w, vchild))
- || !NILP (WVAR (w, hchild))
- || !NILP (WVAR (w, next))
- || !NILP (WVAR (w, prev))
+ if (!NILP (WGET (w, parent))
+ || !NILP (WGET (w, vchild))
+ || !NILP (WGET (w, hchild))
+ || !NILP (WGET (w, next))
+ || !NILP (WGET (w, prev))
|| WINDOW_WANTS_MODELINE_P (w))
--ht;
/* If we must, use the pixel-based version which is much slower than
the line-based one but can handle varying line heights. */
- if (FRAME_WINDOW_P (XFRAME (WVAR (XWINDOW (window), frame))))
+ if (FRAME_WINDOW_P (XFRAME (WGET (XWINDOW (window), frame))))
window_scroll_pixel_based (window, n, whole, noerror);
else
window_scroll_line_based (window, n, whole, noerror);
int x, y, rtop, rbot, rowh, vpos;
void *itdata = NULL;
- SET_TEXT_POS_FROM_MARKER (start, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
/* Scrolling a minibuffer window via scroll bar when the echo area
shows long text sometimes resets the minibuffer contents behind
our backs. */
spos = XINT (Fline_beginning_position (Qnil));
else
spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
- set_marker_restricted (WVAR (w, start), make_number (spos),
- WVAR (w, buffer));
+ set_marker_restricted (WGET (w, start), make_number (spos),
+ WGET (w, buffer));
w->start_at_line_beg = 1;
w->update_mode_line = 1;
w->last_modified = 0;
/* If control gets here, then we vscrolled. */
- XBUFFER (WVAR (w, buffer))->prevent_redisplay_optimizations_p = 1;
+ XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
/* Don't try to change the window start below. */
vscrolled = 1;
}
/* Set the window start, and set up the window for redisplay. */
- set_marker_restricted (WVAR (w, start), make_number (pos),
- WVAR (w, buffer));
- bytepos = XMARKER (WVAR (w, start))->bytepos;
+ set_marker_restricted (WGET (w, start), make_number (pos),
+ WGET (w, buffer));
+ bytepos = XMARKER (WGET (w, start))->bytepos;
w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
w->update_mode_line = 1;
w->last_modified = 0;
even if there is a header line. */
this_scroll_margin = max (0, scroll_margin);
this_scroll_margin
- = min (this_scroll_margin, XFASTINT (WVAR (w, total_lines)) / 4);
+ = min (this_scroll_margin, XFASTINT (WGET (w, total_lines)) / 4);
this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
if (n > 0)
;
else if (window_scroll_pixel_based_preserve_y >= 0)
{
- SET_TEXT_POS_FROM_MARKER (start, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
start_display (&it, w, start);
/* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
here because we called start_display again and did not
if (whole)
n *= max (1, ht - next_screen_context_lines);
- startpos = marker_position (WVAR (w, start));
+ startpos = marker_position (WGET (w, start));
if (!NILP (Vscroll_preserve_screen_position))
{
{
/* Don't use a scroll margin that is negative or too large. */
int this_scroll_margin =
- max (0, min (scroll_margin, XINT (WVAR (w, total_lines)) / 4));
+ max (0, min (scroll_margin, XINT (WGET (w, total_lines)) / 4));
- set_marker_restricted_both (WVAR (w, start), WVAR (w, buffer), pos, pos_byte);
+ set_marker_restricted_both (WGET (w, start), WGET (w, buffer), pos, pos_byte);
w->start_at_line_beg = !NILP (bolp);
w->update_mode_line = 1;
w->last_modified = 0;
/* If selected window's buffer isn't current, make it current for
the moment. But don't screw up if window_scroll gets an error. */
- if (XBUFFER (WVAR (XWINDOW (selected_window), buffer)) != current_buffer)
+ if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) != current_buffer)
{
record_unwind_protect (save_excursion_restore, save_excursion_save ());
- Fset_buffer (WVAR (XWINDOW (selected_window), buffer));
+ Fset_buffer (WGET (XWINDOW (selected_window), buffer));
/* Make redisplay consider other windows than just selected_window. */
++windows_or_buffers_changed;
record_unwind_protect (save_excursion_restore, save_excursion_save ());
++windows_or_buffers_changed;
- Fset_buffer (WVAR (w, buffer));
- SET_PT (marker_position (WVAR (w, pointm)));
+ Fset_buffer (WGET (w, buffer));
+ SET_PT (marker_position (WGET (w, pointm)));
if (NILP (arg))
window_scroll (window, 1, 1, 1);
window_scroll (window, XINT (arg), 0, 1);
}
- set_marker_both (WVAR (w, pointm), Qnil, PT, PT_BYTE);
+ set_marker_both (WGET (w, pointm), Qnil, PT, PT_BYTE);
unbind_to (count, Qnil);
return Qnil;
int bottom_y;
void *itdata = NULL;
- if (XBUFFER (WVAR (w, buffer)) != current_buffer)
+ if (XBUFFER (WGET (w, buffer)) != current_buffer)
{
old_buffer = current_buffer;
- set_buffer_internal (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal (XBUFFER (WGET (w, buffer)));
}
else
old_buffer = NULL;
/* 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 (WVAR (w, start))->charpos < BEGV)
+ if (XMARKER (WGET (w, start))->charpos < BEGV)
SET_TEXT_POS (start, BEGV, BEGV_BYTE);
- else if (XMARKER (WVAR (w, start))->charpos > ZV)
+ else if (XMARKER (WGET (w, start))->charpos > ZV)
SET_TEXT_POS (start, ZV, ZV_BYTE);
else
- SET_TEXT_POS_FROM_MARKER (start, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
itdata = bidi_shelve_cache ();
start_display (&it, w, start);
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 (WVAR (w, frame))))
+ if (! FRAME_WINDOW_P (XFRAME (WGET (w, frame))))
height++;
/* Add in empty lines at the bottom of the window. */
(register Lisp_Object arg)
{
struct window *w = XWINDOW (selected_window);
- struct buffer *buf = XBUFFER (WVAR (w, buffer));
+ struct buffer *buf = XBUFFER (WGET (w, buffer));
struct buffer *obuf = current_buffer;
int center_p = 0;
ptrdiff_t charpos, bytepos;
/* Do this after making BUF current
in case scroll_margin is buffer-local. */
this_scroll_margin =
- max (0, min (scroll_margin, XFASTINT (WVAR (w, total_lines)) / 4));
+ max (0, min (scroll_margin, XFASTINT (WGET (w, total_lines)) / 4));
/* Handle centering on a graphical frame specially. Such frames can
have variable-height lines and centering point on the basis of
line counts would lead to strange effects. */
- if (FRAME_WINDOW_P (XFRAME (WVAR (w, frame))))
+ if (FRAME_WINDOW_P (XFRAME (WGET (w, frame))))
{
if (center_p)
{
}
/* Set the new window start. */
- set_marker_both (WVAR (w, start), WVAR (w, buffer), charpos, bytepos);
- WVAR (w, window_end_valid) = Qnil;
+ set_marker_both (WGET (w, start), WGET (w, buffer), charpos, bytepos);
+ WSET (w, window_end_valid, Qnil);
w->optional_new_start = 1;
{
struct window *w = decode_window (window);
int pixel_height = window_box_height (w);
- int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (WVAR (w, frame)));
+ int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (WGET (w, frame)));
return make_number (line_height);
}
int this_scroll_margin;
#endif
- if (!(BUFFERP (WVAR (w, buffer))
- && XBUFFER (WVAR (w, buffer)) == current_buffer))
+ if (!(BUFFERP (WGET (w, buffer))
+ && XBUFFER (WGET (w, buffer)) == current_buffer))
/* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
when passed below to set_marker_both. */
error ("move-to-window-line called from unrelated buffer");
window = selected_window;
- start = marker_position (WVAR (w, start));
+ start = marker_position (WGET (w, start));
if (start < BEGV || start > ZV)
{
int height = window_internal_height (w);
Fvertical_motion (make_number (- (height / 2)), window);
- set_marker_both (WVAR (w, start), WVAR (w, buffer), PT, PT_BYTE);
+ set_marker_both (WGET (w, start), WGET (w, buffer), PT, PT_BYTE);
w->start_at_line_beg = !NILP (Fbolp ());
w->force_start = 1;
}
else
- Fgoto_char (WVAR (w, start));
+ Fgoto_char (WGET (w, start));
lines = displayed_window_lines (w);
data = (struct save_window_data *) XVECTOR (config);
saved_windows = XVECTOR (data->saved_windows);
- return WVAR (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window), frame);
+ return WGET (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window), frame);
}
DEFUN ("set-window-configuration", Fset_window_configuration,
window-point of the final-selected-window to the window-point of
the current-selected-window. So we have to be careful which
point of the current-buffer we copy into old_point. */
- if (EQ (WVAR (XWINDOW (data->current_window), buffer), new_current_buffer)
+ if (EQ (WGET (XWINDOW (data->current_window), buffer), new_current_buffer)
&& WINDOWP (selected_window)
- && EQ (WVAR (XWINDOW (selected_window), buffer), new_current_buffer)
+ && EQ (WGET (XWINDOW (selected_window), buffer), new_current_buffer)
&& !EQ (selected_window, data->current_window))
- old_point = XMARKER (WVAR (XWINDOW (data->current_window), pointm))->charpos;
+ old_point = XMARKER (WGET (XWINDOW (data->current_window), pointm))->charpos;
else
old_point = PT;
else
So if possible we want this arbitrary choice of "which point" to
be the one from the to-be-selected-window so as to prevent this
window's cursor from being copied from another window. */
- if (EQ (WVAR (XWINDOW (data->current_window), buffer), new_current_buffer)
+ if (EQ (WGET (XWINDOW (data->current_window), buffer), new_current_buffer)
/* If current_window = selected_window, its point is in BUF_PT. */
&& !EQ (selected_window, data->current_window))
- old_point = XMARKER (WVAR (XWINDOW (data->current_window), pointm))->charpos;
+ old_point = XMARKER (WGET (XWINDOW (data->current_window), pointm))->charpos;
else
old_point = BUF_PT (XBUFFER (new_current_buffer));
}
- frame = WVAR (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window), frame);
+ frame = WGET (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.
window holds garbage.) We do this now, before
restoring the window contents, and prevent it from
being done later on when we select a new window. */
- if (! NILP (WVAR (XWINDOW (selected_window), buffer)))
+ if (! NILP (WGET (XWINDOW (selected_window), buffer)))
{
w = XWINDOW (selected_window);
- set_marker_both (WVAR (w, pointm),
- WVAR (w, buffer),
- BUF_PT (XBUFFER (WVAR (w, buffer))),
- BUF_PT_BYTE (XBUFFER (WVAR (w, buffer))));
+ set_marker_both (WGET (w, pointm),
+ WGET (w, buffer),
+ BUF_PT (XBUFFER (WGET (w, buffer))),
+ BUF_PT_BYTE (XBUFFER (WGET (w, buffer))));
}
windows_or_buffers_changed++;
p = SAVED_WINDOW_N (saved_windows, k);
window = p->window;
w = XWINDOW (window);
- WVAR (w, next) = Qnil;
+ WSET (w, next, Qnil);
if (!NILP (p->parent))
- WVAR (w, parent) = SAVED_WINDOW_N (saved_windows,
- XFASTINT (p->parent))->window;
+ WSET (w, parent, SAVED_WINDOW_N (saved_windows,
+ XFASTINT (p->parent))->window);
else
- WVAR (w, parent) = Qnil;
+ WSET (w, parent, Qnil);
if (!NILP (p->prev))
{
- WVAR (w, prev) = SAVED_WINDOW_N (saved_windows,
- XFASTINT (p->prev))->window;
- WVAR (XWINDOW (WVAR (w, prev)), next) = p->window;
+ WSET (w, prev, SAVED_WINDOW_N (saved_windows,
+ XFASTINT (p->prev))->window);
+ WSET (XWINDOW (WGET (w, prev)), next, p->window);
}
else
{
- WVAR (w, prev) = Qnil;
- if (!NILP (WVAR (w, parent)))
+ WSET (w, prev, Qnil);
+ if (!NILP (WGET (w, parent)))
{
- if (EQ (p->total_cols, WVAR (XWINDOW (WVAR (w, parent)), total_cols)))
+ if (EQ (p->total_cols, WGET (XWINDOW (WGET (w, parent)), total_cols)))
{
- WVAR (XWINDOW (WVAR (w, parent)), vchild) = p->window;
- WVAR (XWINDOW (WVAR (w, parent)), hchild) = Qnil;
+ WSET (XWINDOW (WGET (w, parent)), vchild, p->window);
+ WSET (XWINDOW (WGET (w, parent)), hchild, Qnil);
}
else
{
- WVAR (XWINDOW (WVAR (w, parent)), hchild) = p->window;
- WVAR (XWINDOW (WVAR (w, parent)), vchild) = Qnil;
+ WSET (XWINDOW (WGET (w, parent)), hchild, p->window);
+ WSET (XWINDOW (WGET (w, parent)), vchild, Qnil);
}
}
}
/* If we squirreled away the buffer in the window's height,
restore it now. */
- if (BUFFERP (WVAR (w, total_lines)))
- WVAR (w, buffer) = WVAR (w, total_lines);
- WVAR (w, left_col) = p->left_col;
- WVAR (w, top_line) = p->top_line;
- WVAR (w, total_cols) = p->total_cols;
- WVAR (w, total_lines) = p->total_lines;
- WVAR (w, normal_cols) = p->normal_cols;
- WVAR (w, normal_lines) = p->normal_lines;
+ if (BUFFERP (WGET (w, total_lines)))
+ WSET (w, buffer, WGET (w, total_lines));
+ WSET (w, left_col, p->left_col);
+ WSET (w, top_line, p->top_line);
+ WSET (w, total_cols, p->total_cols);
+ WSET (w, total_lines, p->total_lines);
+ WSET (w, normal_cols, p->normal_cols);
+ WSET (w, normal_lines, p->normal_lines);
w->hscroll = XFASTINT (p->hscroll);
w->min_hscroll = XFASTINT (p->min_hscroll);
- WVAR (w, display_table) = p->display_table;
- WVAR (w, left_margin_cols) = p->left_margin_cols;
- WVAR (w, right_margin_cols) = p->right_margin_cols;
- WVAR (w, left_fringe_width) = p->left_fringe_width;
- WVAR (w, right_fringe_width) = p->right_fringe_width;
+ WSET (w, display_table, p->display_table);
+ WSET (w, left_margin_cols, p->left_margin_cols);
+ WSET (w, right_margin_cols, p->right_margin_cols);
+ WSET (w, left_fringe_width, p->left_fringe_width);
+ WSET (w, right_fringe_width, p->right_fringe_width);
w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
- WVAR (w, scroll_bar_width) = p->scroll_bar_width;
- WVAR (w, vertical_scroll_bar_type) = p->vertical_scroll_bar_type;
- WVAR (w, dedicated) = p->dedicated;
- WVAR (w, combination_limit) = p->combination_limit;
+ WSET (w, scroll_bar_width, p->scroll_bar_width);
+ WSET (w, vertical_scroll_bar_type, p->vertical_scroll_bar_type);
+ WSET (w, dedicated, p->dedicated);
+ WSET (w, combination_limit, p->combination_limit);
/* Restore any window parameters that have been saved.
Parameters that have not been saved are left alone. */
for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
{
if (NILP (XCDR (pers)))
{
- par = Fassq (XCAR (pers), WVAR (w, window_parameters));
+ par = Fassq (XCAR (pers), WGET (w, window_parameters));
if (CONSP (par) && !NILP (XCDR (par)))
/* Reset a parameter to nil if and only if it
has a non-nil association. Don't make new
/* Reinstall the saved buffer and pointers into it. */
if (NILP (p->buffer))
/* An internal window. */
- WVAR (w, buffer) = p->buffer;
+ WSET (w, buffer, p->buffer);
else if (!NILP (BVAR (XBUFFER (p->buffer), name)))
/* If saved buffer is alive, install it. */
{
- WVAR (w, buffer) = p->buffer;
- w->start_at_line_beg = !NILP (p->start_at_line_beg);
- set_marker_restricted (WVAR (w, start), p->start, WVAR (w, buffer));
- set_marker_restricted (WVAR (w, pointm), p->pointm,
- WVAR (w, buffer));
- Fset_marker (BVAR (XBUFFER (WVAR (w, buffer)), mark),
- p->mark, WVAR (w, buffer));
-
- /* As documented in Fcurrent_window_configuration, don't
- 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 (WVAR (w, pointm));
- }
- else if (!NILP (WVAR (w, buffer))
- && !NILP (BVAR (XBUFFER (WVAR (w, buffer)), name)))
- /* Keep window's old buffer; make sure the markers are
- real. */
- {
- /* Set window markers at start of visible range. */
- if (XMARKER (WVAR (w, start))->buffer == 0)
- set_marker_restricted (WVAR (w, start), make_number (0),
- WVAR (w, buffer));
- if (XMARKER (WVAR (w, pointm))->buffer == 0)
- set_marker_restricted_both
- (WVAR (w, pointm), WVAR (w, buffer),
- BUF_PT (XBUFFER (WVAR (w, buffer))),
- BUF_PT_BYTE (XBUFFER (WVAR (w, buffer))));
- w->start_at_line_beg = 1;
- }
- else if (STRINGP (auto_buffer_name =
- Fwindow_parameter (window, Qauto_buffer_name))
- && SCHARS (auto_buffer_name) != 0
- && !NILP (WVAR (w, buffer) = Fget_buffer_create (auto_buffer_name)))
+ WSET (w, buffer, p->buffer);
+ w->start_at_line_beg = !NILP (p->start_at_line_beg);
+ set_marker_restricted (WGET (w, start), p->start, WGET (w, buffer));
+ set_marker_restricted (WGET (w, pointm), p->pointm,
+ WGET (w, buffer));
+ Fset_marker (BVAR (XBUFFER (WGET (w, buffer)), mark),
+ p->mark, WGET (w, buffer));
+
+ /* As documented in Fcurrent_window_configuration, don't
+ 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 (WGET (w, pointm));
+ }
+ else if (!NILP (WGET (w, buffer))
+ && !NILP (BVAR (XBUFFER (WGET (w, buffer)), name)))
+ /* Keep window's old buffer; make sure the markers are
+ real. */
+ {
+ /* Set window markers at start of visible range. */
+ if (XMARKER (WGET (w, start))->buffer == 0)
+ set_marker_restricted (WGET (w, start), make_number (0),
+ WGET (w, buffer));
+ if (XMARKER (WGET (w, pointm))->buffer == 0)
+ set_marker_restricted_both
+ (WGET (w, pointm), WGET (w, buffer),
+ BUF_PT (XBUFFER (WGET (w, buffer))),
+ BUF_PT_BYTE (XBUFFER (WGET (w, buffer))));
+ w->start_at_line_beg = 1;
+ }
+ else if (STRINGP (auto_buffer_name =
+ Fwindow_parameter (window, Qauto_buffer_name))
+ && SCHARS (auto_buffer_name) != 0
+ && !NILP (WSET (w, buffer, Fget_buffer_create (auto_buffer_name))))
{
- set_marker_restricted (WVAR (w, start),
- make_number (0), WVAR (w, buffer));
- set_marker_restricted (WVAR (w, pointm),
- make_number (0), WVAR (w, buffer));
+ set_marker_restricted (WGET (w, start),
+ make_number (0), WGET (w, buffer));
+ set_marker_restricted (WGET (w, pointm),
+ make_number (0), WGET (w, buffer));
w->start_at_line_beg = 1;
}
else
avoid showing an unimportant buffer and, if necessary, to
recreate *scratch* in the course (part of Juanma's bs-show
scenario from March 2011). */
- WVAR (w, buffer) = other_buffer_safely (Fcurrent_buffer ());
+ WSET (w, buffer, other_buffer_safely (Fcurrent_buffer ()));
/* This will set the markers to beginning of visible
range. */
- set_marker_restricted (WVAR (w, start),
- make_number (0), WVAR (w, buffer));
- set_marker_restricted (WVAR (w, pointm),
- make_number (0), WVAR (w, buffer));
+ set_marker_restricted (WGET (w, start),
+ make_number (0), WGET (w, buffer));
+ set_marker_restricted (WGET (w, pointm),
+ make_number (0), WGET (w, buffer));
w->start_at_line_beg = 1;
- if (!NILP (WVAR (w, dedicated)))
+ if (!NILP (WGET (w, dedicated)))
/* Record this window as dead. */
dead_windows = Fcons (window, dead_windows);
/* Make sure window is no more dedicated. */
- WVAR (w, dedicated) = Qnil;
+ WSET (w, dedicated, Qnil);
}
}
FSET (f, root_window, data->root_window);
/* Arrange *not* to restore point in the buffer that was
current when the window configuration was saved. */
- if (EQ (WVAR (XWINDOW (data->current_window), buffer), new_current_buffer))
- set_marker_restricted (WVAR (XWINDOW (data->current_window), pointm),
+ if (EQ (WGET (XWINDOW (data->current_window), buffer), new_current_buffer))
+ set_marker_restricted (WGET (XWINDOW (data->current_window), pointm),
make_number (old_point),
- WVAR (XWINDOW (data->current_window), buffer));
+ WGET (XWINDOW (data->current_window), buffer));
/* In the following call to `select-window', prevent "swapping out
point" in the old selected window using the buffer that has
been restored into it. We already swapped out that point from
that window's old buffer. */
select_window (data->current_window, Qnil, 1);
- BVAR (XBUFFER (WVAR (XWINDOW (selected_window), buffer)), last_selected_window)
+ BVAR (XBUFFER (WGET (XWINDOW (selected_window), buffer)), last_selected_window)
= selected_window;
if (NILP (data->focus_frame)
/* Now, free glyph matrices in windows that were not reused. */
for (i = n = 0; i < n_leaf_windows; ++i)
{
- if (NILP (WVAR (leaf_windows[i], buffer)))
+ if (NILP (WGET (leaf_windows[i], buffer)))
{
/* Assert it's not reused as a combination. */
- eassert (NILP (WVAR (leaf_windows[i], hchild))
- && NILP (WVAR (leaf_windows[i], vchild)));
+ eassert (NILP (WGET (leaf_windows[i], hchild))
+ && NILP (WGET (leaf_windows[i], vchild)));
free_window_matrices (leaf_windows[i]);
}
- else if (EQ (WVAR (leaf_windows[i], buffer), new_current_buffer))
+ else if (EQ (WGET (leaf_windows[i], buffer), new_current_buffer))
++n;
}
w = XWINDOW (window);
- if (!NILP (WVAR (w, next)))
+ if (!NILP (WGET (w, next)))
/* Delete WINDOW's siblings (we traverse postorderly). */
- delete_all_child_windows (WVAR (w, next));
+ delete_all_child_windows (WGET (w, next));
- WVAR (w, total_lines) = WVAR (w, buffer); /* See Fset_window_configuration for excuse. */
+ WSET (w, total_lines, WGET (w, buffer)); /* See Fset_window_configuration for excuse. */
- if (!NILP (WVAR (w, vchild)))
+ if (!NILP (WGET (w, vchild)))
{
- delete_all_child_windows (WVAR (w, vchild));
- WVAR (w, vchild) = Qnil;
+ delete_all_child_windows (WGET (w, vchild));
+ WSET (w, vchild, Qnil);
}
- else if (!NILP (WVAR (w, hchild)))
+ else if (!NILP (WGET (w, hchild)))
{
- delete_all_child_windows (WVAR (w, hchild));
- WVAR (w, hchild) = Qnil;
+ delete_all_child_windows (WGET (w, hchild));
+ WSET (w, hchild, Qnil);
}
- else if (!NILP (WVAR (w, buffer)))
+ else if (!NILP (WGET (w, buffer)))
{
unshow_buffer (w);
- unchain_marker (XMARKER (WVAR (w, pointm)));
- unchain_marker (XMARKER (WVAR (w, start)));
- WVAR (w, buffer) = Qnil;
+ unchain_marker (XMARKER (WGET (w, pointm)));
+ unchain_marker (XMARKER (WGET (w, start)));
+ WSET (w, buffer, Qnil);
}
Vwindow_list = Qnil;
count_windows (register struct window *window)
{
register int count = 1;
- if (!NILP (WVAR (window, next)))
- count += count_windows (XWINDOW (WVAR (window, next)));
- if (!NILP (WVAR (window, vchild)))
- count += count_windows (XWINDOW (WVAR (window, vchild)));
- if (!NILP (WVAR (window, hchild)))
- count += count_windows (XWINDOW (WVAR (window, hchild)));
+ if (!NILP (WGET (window, next)))
+ count += count_windows (XWINDOW (WGET (window, next)));
+ if (!NILP (WGET (window, vchild)))
+ count += count_windows (XWINDOW (WGET (window, vchild)));
+ if (!NILP (WGET (window, hchild)))
+ count += count_windows (XWINDOW (WGET (window, hchild)));
return count;
}
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- i = get_leaf_windows (XWINDOW (WVAR (w, hchild)), flat, i);
- else if (!NILP (WVAR (w, vchild)))
- i = get_leaf_windows (XWINDOW (WVAR (w, vchild)), flat, i);
+ if (!NILP (WGET (w, hchild)))
+ i = get_leaf_windows (XWINDOW (WGET (w, hchild)), flat, i);
+ else if (!NILP (WGET (w, vchild)))
+ i = get_leaf_windows (XWINDOW (WGET (w, vchild)), flat, i);
else
flat[i++] = w;
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
return i;
register struct window *w;
register Lisp_Object tem, pers, par;
- for (;!NILP (window); window = WVAR (w, next))
+ for (;!NILP (window); window = WGET (w, next))
{
p = SAVED_WINDOW_N (vector, i);
w = XWINDOW (window);
- XSETFASTINT (WVAR (w, temslot), i); i++;
+ WSET (w, temslot, make_number (i)); i++;
p->window = window;
- p->buffer = WVAR (w, buffer);
- p->left_col = WVAR (w, left_col);
- p->top_line = WVAR (w, top_line);
- p->total_cols = WVAR (w, total_cols);
- p->total_lines = WVAR (w, total_lines);
- p->normal_cols = WVAR (w, normal_cols);
- p->normal_lines = WVAR (w, normal_lines);
+ p->buffer = WGET (w, buffer);
+ p->left_col = WGET (w, left_col);
+ p->top_line = WGET (w, top_line);
+ p->total_cols = WGET (w, total_cols);
+ p->total_lines = WGET (w, total_lines);
+ p->normal_cols = WGET (w, normal_cols);
+ p->normal_lines = WGET (w, normal_lines);
XSETFASTINT (p->hscroll, w->hscroll);
XSETFASTINT (p->min_hscroll, w->min_hscroll);
- p->display_table = WVAR (w, display_table);
- p->left_margin_cols = WVAR (w, left_margin_cols);
- p->right_margin_cols = WVAR (w, right_margin_cols);
- p->left_fringe_width = WVAR (w, left_fringe_width);
- p->right_fringe_width = WVAR (w, right_fringe_width);
+ p->display_table = WGET (w, display_table);
+ p->left_margin_cols = WGET (w, left_margin_cols);
+ p->right_margin_cols = WGET (w, right_margin_cols);
+ p->left_fringe_width = WGET (w, left_fringe_width);
+ p->right_fringe_width = WGET (w, right_fringe_width);
p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;
- p->scroll_bar_width = WVAR (w, scroll_bar_width);
- p->vertical_scroll_bar_type = WVAR (w, vertical_scroll_bar_type);
- p->dedicated = WVAR (w, dedicated);
- p->combination_limit = WVAR (w, combination_limit);
+ p->scroll_bar_width = WGET (w, scroll_bar_width);
+ p->vertical_scroll_bar_type = WGET (w, vertical_scroll_bar_type);
+ p->dedicated = WGET (w, dedicated);
+ p->combination_limit = WGET (w, combination_limit);
p->window_parameters = Qnil;
if (!NILP (Vwindow_persistent_parameters))
/* Save values for persistent window parameters. */
if (CONSP (pers) && !NILP (XCDR (pers)))
{
- par = Fassq (XCAR (pers), WVAR (w, window_parameters));
+ par = Fassq (XCAR (pers), WGET (w, window_parameters));
if (NILP (par))
/* If the window has no value for the parameter,
make one. */
}
}
- if (!NILP (WVAR (w, buffer)))
+ if (!NILP (WGET (w, buffer)))
{
/* Save w's value of point in the window configuration. If w
is the selected window, then get the value of point from
the buffer; pointm is garbage in the selected window. */
if (EQ (window, selected_window))
- p->pointm = build_marker (XBUFFER (WVAR (w, buffer)),
- BUF_PT (XBUFFER (WVAR (w, buffer))),
- BUF_PT_BYTE (XBUFFER (WVAR (w, buffer))));
+ p->pointm = build_marker (XBUFFER (WGET (w, buffer)),
+ BUF_PT (XBUFFER (WGET (w, buffer))),
+ BUF_PT_BYTE (XBUFFER (WGET (w, buffer))));
else
- p->pointm = Fcopy_marker (WVAR (w, pointm), Qnil);
+ p->pointm = Fcopy_marker (WGET (w, pointm), Qnil);
XMARKER (p->pointm)->insertion_type
= !NILP (Vwindow_point_insertion_type);
- p->start = Fcopy_marker (WVAR (w, start), Qnil);
+ p->start = Fcopy_marker (WGET (w, start), Qnil);
p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
- tem = BVAR (XBUFFER (WVAR (w, buffer)), mark);
+ tem = BVAR (XBUFFER (WGET (w, buffer)), mark);
p->mark = Fcopy_marker (tem, Qnil);
}
else
p->start_at_line_beg = Qnil;
}
- if (NILP (WVAR (w, parent)))
+ if (NILP (WGET (w, parent)))
p->parent = Qnil;
else
- p->parent = WVAR (XWINDOW (WVAR (w, parent)), temslot);
+ p->parent = WGET (XWINDOW (WGET (w, parent)), temslot);
- if (NILP (WVAR (w, prev)))
+ if (NILP (WGET (w, prev)))
p->prev = Qnil;
else
- p->prev = WVAR (XWINDOW (WVAR (w, prev)), temslot);
+ p->prev = WGET (XWINDOW (WGET (w, prev)), temslot);
- if (!NILP (WVAR (w, vchild)))
- i = save_window_save (WVAR (w, vchild), vector, i);
- if (!NILP (WVAR (w, hchild)))
- i = save_window_save (WVAR (w, hchild), vector, i);
+ if (!NILP (WGET (w, vchild)))
+ i = save_window_save (WGET (w, vchild), vector, i);
+ if (!NILP (WGET (w, hchild)))
+ i = save_window_save (WGET (w, hchild), vector, i);
}
return i;
right_width = Qnil;
}
- if (!EQ (WVAR (w, left_margin_cols), left_width)
- || !EQ (WVAR (w, right_margin_cols), right_width))
+ if (!EQ (WGET (w, left_margin_cols), left_width)
+ || !EQ (WGET (w, right_margin_cols), right_width))
{
- WVAR (w, left_margin_cols) = left_width;
- WVAR (w, right_margin_cols) = right_width;
+ WSET (w, left_margin_cols, left_width);
+ WSET (w, right_margin_cols, right_width);
adjust_window_margins (w);
(Lisp_Object window)
{
struct window *w = decode_window (window);
- return Fcons (WVAR (w, left_margin_cols), WVAR (w, right_margin_cols));
+ return Fcons (WGET (w, left_margin_cols), WGET (w, right_margin_cols));
}
/* Do nothing on a tty. */
if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
- && (!EQ (WVAR (w, left_fringe_width), left_width)
- || !EQ (WVAR (w, right_fringe_width), right_width)
+ && (!EQ (WGET (w, left_fringe_width), left_width)
+ || !EQ (WGET (w, right_fringe_width), right_width)
|| w->fringes_outside_margins != outside))
{
- WVAR (w, left_fringe_width) = left_width;
- WVAR (w, right_fringe_width) = right_width;
+ WSET (w, left_fringe_width, left_width);
+ WSET (w, right_fringe_width, right_width);
w->fringes_outside_margins = outside;
adjust_window_margins (w);
clear_glyph_matrix (w->current_matrix);
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
++windows_or_buffers_changed;
adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
|| EQ (vertical_type, Qt)))
error ("Invalid type of vertical scroll bar");
- if (!EQ (WVAR (w, scroll_bar_width), width)
- || !EQ (WVAR (w, vertical_scroll_bar_type), vertical_type))
+ if (!EQ (WGET (w, scroll_bar_width), width)
+ || !EQ (WGET (w, vertical_scroll_bar_type), vertical_type))
{
- WVAR (w, scroll_bar_width) = width;
- WVAR (w, vertical_scroll_bar_type) = vertical_type;
+ WSET (w, scroll_bar_width, width);
+ WSET (w, vertical_scroll_bar_type, vertical_type);
adjust_window_margins (w);
clear_glyph_matrix (w->current_matrix);
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
++windows_or_buffers_changed;
adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
: WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w)),
- Fcons (WVAR (w, vertical_scroll_bar_type),
+ Fcons (WGET (w, vertical_scroll_bar_type),
Fcons (Qnil, Qnil))));
}
else
CHECK_WINDOW (window);
w = XWINDOW (window);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
if (FRAME_WINDOW_P (f))
result = (NILP (pixels_p)
CHECK_NUMBER_OR_FLOAT (vscroll);
w = XWINDOW (window);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
if (FRAME_WINDOW_P (f))
{
adjust_glyphs (f);
/* Prevent redisplay shortcuts. */
- XBUFFER (WVAR (w, buffer))->prevent_redisplay_optimizations_p = 1;
+ XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
}
}
for (cont = 1; w && cont;)
{
- if (!NILP (WVAR (w, hchild)))
- cont = foreach_window_1 (XWINDOW (WVAR (w, hchild)), fn, user_data);
- else if (!NILP (WVAR (w, vchild)))
- cont = foreach_window_1 (XWINDOW (WVAR (w, vchild)), fn, user_data);
+ if (!NILP (WGET (w, hchild)))
+ cont = foreach_window_1 (XWINDOW (WGET (w, hchild)), fn, user_data);
+ else if (!NILP (WGET (w, vchild)))
+ cont = foreach_window_1 (XWINDOW (WGET (w, vchild)), fn, user_data);
else
cont = fn (w, user_data);
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
return cont;
int hpos, vpos;
};
-/* Most code should use this macro to access Lisp fields in struct window. */
+/* Most code should use these macros to access Lisp fields
+ in struct window. WGET should not be used as lvalue. */
-#define WVAR(w, field) ((w)->INTERNAL_FIELD (field))
+#define WGET(f, field) \
+ (eassert (offsetof (struct window, field ## _) \
+ < offsetof (struct window, current_matrix)), \
+ ((f)->INTERNAL_FIELD (field)))
+
+#define WSET(w, field, value) ((w)->INTERNAL_FIELD (field) = (value))
struct window
{
This includes scroll bars and fringes. */
#define WINDOW_TOTAL_COLS(W) \
- (XFASTINT (WVAR (W, total_cols)))
+ (XFASTINT (WGET (W, total_cols)))
/* Return the height of window W in canonical line units.
This includes header and mode lines, if any. */
#define WINDOW_TOTAL_LINES(W) \
- (XFASTINT (WVAR (W, total_lines)))
+ (XFASTINT (WGET (W, total_lines)))
/* Return the total pixel width of window W. */
This includes a left-hand scroll bar, if any. */
#define WINDOW_LEFT_EDGE_COL(W) \
- (XFASTINT (WVAR (W, left_col)))
+ (XFASTINT (WGET (W, left_col)))
/* Return the canonical frame column before which window W ends.
This includes a right-hand scroll bar, if any. */
This includes a header line, if any. */
#define WINDOW_TOP_EDGE_LINE(W) \
- (XFASTINT (WVAR (W, top_line)))
+ (XFASTINT (WGET (W, top_line)))
/* Return the canonical frame line before which window W ends.
This includes a mode line, if any. */
/* Width of left margin area in columns. */
#define WINDOW_LEFT_MARGIN_COLS(W) \
- (NILP (WVAR (W, left_margin_cols)) \
+ (NILP (WGET (W, left_margin_cols)) \
? 0 \
- : XINT (WVAR (W, left_margin_cols)))
+ : XINT (WGET (W, left_margin_cols)))
/* Width of right marginal area in columns. */
#define WINDOW_RIGHT_MARGIN_COLS(W) \
- (NILP (WVAR (W, right_margin_cols)) \
+ (NILP (WGET (W, right_margin_cols)) \
? 0 \
- : XINT (WVAR (W, right_margin_cols)))
+ : XINT (WGET (W, right_margin_cols)))
/* Width of left margin area in pixels. */
#define WINDOW_LEFT_MARGIN_WIDTH(W) \
- (NILP (WVAR (W, left_margin_cols)) \
+ (NILP (WGET (W, left_margin_cols)) \
? 0 \
- : (XINT (WVAR (W, left_margin_cols)) \
+ : (XINT (WGET (W, left_margin_cols)) \
* WINDOW_FRAME_COLUMN_WIDTH (W)))
/* Width of right marginal area in pixels. */
#define WINDOW_RIGHT_MARGIN_WIDTH(W) \
- (NILP (WVAR (W, right_margin_cols)) \
+ (NILP (WGET (W, right_margin_cols)) \
? 0 \
- : (XINT (WVAR (W, right_margin_cols)) \
+ : (XINT (WGET (W, right_margin_cols)) \
* WINDOW_FRAME_COLUMN_WIDTH (W)))
/* Total width of fringes reserved for drawing truncation bitmaps,
able to split windows horizontally nicely. */
#define WINDOW_FRINGE_COLS(W) \
- ((INTEGERP (WVAR (W, left_fringe_width)) \
- || INTEGERP (WVAR (W, right_fringe_width))) \
+ ((INTEGERP (WGET (W, left_fringe_width)) \
+ || INTEGERP (WGET (W, right_fringe_width))) \
? ((WINDOW_LEFT_FRINGE_WIDTH (W) \
+ WINDOW_RIGHT_FRINGE_WIDTH (W) \
+ WINDOW_FRAME_COLUMN_WIDTH (W) - 1) \
/* Pixel-width of the left and right fringe. */
#define WINDOW_LEFT_FRINGE_WIDTH(W) \
- (INTEGERP (WVAR (W, left_fringe_width)) \
- ? XFASTINT (WVAR (W, left_fringe_width)) \
+ (INTEGERP (WGET (W, left_fringe_width)) \
+ ? XFASTINT (WGET (W, left_fringe_width)) \
: FRAME_LEFT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
#define WINDOW_RIGHT_FRINGE_WIDTH(W) \
- (INTEGERP (WVAR (W, right_fringe_width)) \
- ? XFASTINT (WVAR (W, right_fringe_width)) \
+ (INTEGERP (WGET (W, right_fringe_width)) \
+ ? XFASTINT (WGET (W, right_fringe_width)) \
: FRAME_RIGHT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
/* Total width of fringes in pixels. */
and which side they are on. */
#define WINDOW_VERTICAL_SCROLL_BAR_TYPE(w) \
- (EQ (WVAR (w, vertical_scroll_bar_type), Qt) \
+ (EQ (WGET (w, vertical_scroll_bar_type), Qt) \
? FRAME_VERTICAL_SCROLL_BAR_TYPE (WINDOW_XFRAME (w)) \
- : EQ (WVAR (w, vertical_scroll_bar_type), Qleft) \
+ : EQ (WGET (w, vertical_scroll_bar_type), Qleft) \
? vertical_scroll_bar_left \
- : EQ (WVAR (w, vertical_scroll_bar_type), Qright) \
+ : EQ (WGET (w, vertical_scroll_bar_type), Qright) \
? vertical_scroll_bar_right \
: vertical_scroll_bar_none) \
#define WINDOW_HAS_VERTICAL_SCROLL_BAR(w) \
- (EQ (WVAR (w, vertical_scroll_bar_type), Qt) \
+ (EQ (WGET (w, vertical_scroll_bar_type), Qt) \
? FRAME_HAS_VERTICAL_SCROLL_BARS (WINDOW_XFRAME (w)) \
- : !NILP (WVAR (w, vertical_scroll_bar_type)))
+ : !NILP (WGET (w, vertical_scroll_bar_type)))
#define WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT(w) \
- (EQ (WVAR (w, vertical_scroll_bar_type), Qt) \
+ (EQ (WGET (w, vertical_scroll_bar_type), Qt) \
? FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (WINDOW_XFRAME (w)) \
- : EQ (WVAR (w, vertical_scroll_bar_type), Qleft))
+ : EQ (WGET (w, vertical_scroll_bar_type), Qleft))
#define WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT(w) \
- (EQ (WVAR (w, vertical_scroll_bar_type), Qt) \
+ (EQ (WGET (w, vertical_scroll_bar_type), Qt) \
? FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (WINDOW_XFRAME (w))\
- : EQ (WVAR (w, vertical_scroll_bar_type), Qright))
+ : EQ (WGET (w, vertical_scroll_bar_type), Qright))
/* Width that a scroll bar in window W should have, if there is one.
Measured in pixels. If scroll bars are turned off, this is still
nonzero. */
#define WINDOW_CONFIG_SCROLL_BAR_WIDTH(w) \
- (INTEGERP (WVAR (w, scroll_bar_width)) \
- ? XFASTINT (WVAR (w, scroll_bar_width)) \
+ (INTEGERP (WGET (w, scroll_bar_width)) \
+ ? XFASTINT (WGET (w, scroll_bar_width)) \
: FRAME_CONFIG_SCROLL_BAR_WIDTH (WINDOW_XFRAME (w)))
/* Width that a scroll bar in window W should have, if there is one.
this is still nonzero. */
#define WINDOW_CONFIG_SCROLL_BAR_COLS(w) \
- (INTEGERP (WVAR (w, scroll_bar_width)) \
- ? ((XFASTINT (WVAR (w, scroll_bar_width)) \
+ (INTEGERP (WGET (w, scroll_bar_width)) \
+ ? ((XFASTINT (WGET (w, scroll_bar_width)) \
+ WINDOW_FRAME_COLUMN_WIDTH (w) - 1) \
/ WINDOW_FRAME_COLUMN_WIDTH (w)) \
: FRAME_CONFIG_SCROLL_BAR_COLS (WINDOW_XFRAME (w)))
/* Value is non-zero if WINDOW is a live window. */
-#define WINDOW_LIVE_P(WINDOW) \
- (WINDOWP ((WINDOW)) && !NILP (WVAR (XWINDOW ((WINDOW)), buffer)))
-
+#define WINDOW_LIVE_P(WINDOW) \
+ (WINDOWP (WINDOW) && !NILP (WGET (XWINDOW (WINDOW), buffer)))
/* These used to be in lisp.h. */
int
window_box_width (struct window *w, int area)
{
- int cols = XFASTINT (WVAR (w, total_cols));
+ int cols = XFASTINT (WGET (w, total_cols));
int pixels = 0;
if (!w->pseudo_window_p)
if (area == TEXT_AREA)
{
- if (INTEGERP (WVAR (w, left_margin_cols)))
- cols -= XFASTINT (WVAR (w, left_margin_cols));
- if (INTEGERP (WVAR (w, right_margin_cols)))
- cols -= XFASTINT (WVAR (w, right_margin_cols));
+ if (INTEGERP (WGET (w, left_margin_cols)))
+ cols -= XFASTINT (WGET (w, left_margin_cols));
+ if (INTEGERP (WGET (w, right_margin_cols)))
+ cols -= XFASTINT (WGET (w, right_margin_cols));
pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
}
else if (area == LEFT_MARGIN_AREA)
{
- cols = (INTEGERP (WVAR (w, left_margin_cols))
- ? XFASTINT (WVAR (w, left_margin_cols)) : 0);
+ cols = (INTEGERP (WGET (w, left_margin_cols))
+ ? XFASTINT (WGET (w, left_margin_cols)) : 0);
pixels = 0;
}
else if (area == RIGHT_MARGIN_AREA)
{
- cols = (INTEGERP (WVAR (w, right_margin_cols))
- ? XFASTINT (WVAR (w, right_margin_cols)) : 0);
+ cols = (INTEGERP (WGET (w, right_margin_cols))
+ ? XFASTINT (WGET (w, right_margin_cols)) : 0);
pixels = 0;
}
}
int
window_box_height (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int height = WINDOW_TOTAL_HEIGHT (w);
eassert (height >= 0);
int
window_box_left (struct window *w, int area)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int x;
if (w->pseudo_window_p)
if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
return visible_p;
- if (XBUFFER (WVAR (w, buffer)) != current_buffer)
+ if (XBUFFER (WGET (w, buffer)) != current_buffer)
{
old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (w, buffer)));
}
- SET_TEXT_POS_FROM_MARKER (top, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (top, WGET (w, start));
/* Scrolling a minibuffer window via scroll bar when the echo area
shows long text sometimes resets the minibuffer contents behind
our backs. */
{
/* A pseudo-window is always full-width, and starts at the
left edge of the frame, plus a frame border. */
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
*x -= FRAME_INTERNAL_BORDER_WIDTH (f);
*y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
}
check_window_end (struct window *w)
{
if (!MINI_WINDOW_P (w)
- && !NILP (WVAR (w, window_end_valid)))
+ && !NILP (WGET (w, window_end_valid)))
{
struct glyph_row *row;
eassert ((row = MATRIX_ROW (w->current_matrix,
- XFASTINT (WVAR (w, window_end_vpos))),
+ XFASTINT (WGET (w, window_end_vpos))),
!row->enabled_p
|| MATRIX_ROW_DISPLAYS_TEXT_P (row)
|| MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
/* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
if (! NILP (Vface_remapping_alist))
remapped_base_face_id
- = lookup_basic_face (XFRAME (WVAR (w, frame)), base_face_id);
+ = lookup_basic_face (XFRAME (WGET (w, frame)), base_face_id);
/* Use one of the mode line rows of W's desired matrix if
appropriate. */
/* The window in which we iterate over current_buffer: */
XSETWINDOW (it->window, w);
it->w = w;
- it->f = XFRAME (WVAR (w, frame));
+ it->f = XFRAME (WGET (w, frame));
it->cmp_it.id = -1;
/* Get the position at which the redisplay_end_trigger hook should
be run, if it is to be run at all. */
- if (MARKERP (WVAR (w, redisplay_end_trigger))
- && XMARKER (WVAR (w, redisplay_end_trigger))->buffer != 0)
+ if (MARKERP (WGET (w, redisplay_end_trigger))
+ && XMARKER (WGET (w, redisplay_end_trigger))->buffer != 0)
it->redisplay_end_trigger_charpos
- = marker_position (WVAR (w, redisplay_end_trigger));
- else if (INTEGERP (WVAR (w, redisplay_end_trigger)))
+ = marker_position (WGET (w, redisplay_end_trigger));
+ else if (INTEGERP (WGET (w, redisplay_end_trigger)))
it->redisplay_end_trigger_charpos =
- clip_to_bounds (PTRDIFF_MIN, XINT (WVAR (w, redisplay_end_trigger)), PTRDIFF_MAX);
+ clip_to_bounds (PTRDIFF_MIN, XINT (WGET (w, redisplay_end_trigger)), PTRDIFF_MAX);
it->tab_width = SANE_TAB_WIDTH (current_buffer);
if it was a text property. */
if (!STRINGP (it->string))
- object = WVAR (it->w, buffer);
+ object = WGET (it->w, buffer);
display_replaced_p = handle_display_spec (it, propval, object, overlay,
position, bufpos,
it->what = IT_IMAGE;
it->image_id = -1; /* no image */
it->position = start_pos;
- it->object = NILP (object) ? WVAR (it->w, buffer) : object;
+ it->object = NILP (object) ? WGET (it->w, buffer) : object;
it->method = GET_FROM_IMAGE;
it->from_overlay = Qnil;
it->face_id = face_id;
it->what = IT_IMAGE;
it->image_id = lookup_image (it->f, value);
it->position = start_pos;
- it->object = NILP (object) ? WVAR (it->w, buffer) : object;
+ it->object = NILP (object) ? WGET (it->w, buffer) : object;
it->method = GET_FROM_IMAGE;
/* Say that we haven't consumed the characters with
it->object = p->u.stretch.object;
break;
case GET_FROM_BUFFER:
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
break;
case GET_FROM_STRING:
it->object = it->string;
else
{
it->method = GET_FROM_BUFFER;
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
}
}
it->end_charpos = p->end_charpos;
IT_STRING_BYTEPOS (*it) = -1;
it->string = Qnil;
it->method = GET_FROM_BUFFER;
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
it->area = TEXT_AREA;
it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
it->sp = 0;
else
{
it->method = GET_FROM_BUFFER;
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
}
it->dpvec = NULL;
setting face_before_selective_p. */
it->saved_face_id = it->face_id;
it->method = GET_FROM_BUFFER;
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
reseat_at_next_visible_line_start (it, 1);
it->face_before_selective_p = 1;
}
/* Record what we have and where it came from. */
it->what = IT_CHARACTER;
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
it->position = it->current.pos;
/* Normally we return the character found above, except when we
/* Since we are *trying* to run these functions, don't try to run
them again, even if they get an error. */
- WVAR (it->w, redisplay_end_trigger) = Qnil;
+ WSET (it->w, redisplay_end_trigger, Qnil);
Frun_hook_with_args (3, args);
/* Notice if it changed the face of the character we are on. */
return 0;
}
it->position = it->current.pos;
- it->object = WVAR (it->w, buffer);
+ it->object = WGET (it->w, buffer);
it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
IT_BYTEPOS (*it), Qnil);
}
&& it->current_x == it->last_visible_x - 1
&& it->c != '\n'
&& it->c != '\t'
- && it->vpos < XFASTINT (WVAR (it->w, window_end_vpos)))
+ && it->vpos < XFASTINT (WGET (it->w, window_end_vpos)))
{
it->continuation_lines_width += it->current_x;
it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
/* Get the frame containing the mini-buffer
that the selected frame is using. */
mini_window = FRAME_MINIBUF_WINDOW (sf);
- frame = WVAR (XWINDOW (mini_window), frame);
+ frame = WGET (XWINDOW (mini_window), frame);
f = XFRAME (frame);
FRAME_SAMPLE_VISIBILITY (f);
set_buffer_internal_1 (XBUFFER (buffer));
if (w)
{
- WVAR (w, buffer) = buffer;
- set_marker_both (WVAR (w, pointm), buffer, BEG, BEG_BYTE);
+ WSET (w, buffer, buffer);
+ set_marker_both (WGET (w, pointm), buffer, BEG, BEG_BYTE);
}
BVAR (current_buffer, undo_list) = Qt;
if (w)
{
XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
- ASET (vector, i, WVAR (w, buffer)); ++i;
- ASET (vector, i, make_number (XMARKER (WVAR (w, pointm))->charpos)); ++i;
- ASET (vector, i, make_number (XMARKER (WVAR (w, pointm))->bytepos)); ++i;
+ ASET (vector, i, WGET (w, buffer)); ++i;
+ ASET (vector, i, make_number (XMARKER (WGET (w, pointm))->charpos)); ++i;
+ ASET (vector, i, make_number (XMARKER (WGET (w, pointm))->bytepos)); ++i;
}
else
{
charpos = AREF (vector, 5);
bytepos = AREF (vector, 6);
- WVAR (w, buffer) = buffer;
- set_marker_both (WVAR (w, pointm), buffer,
+ WSET (w, buffer, buffer);
+ set_marker_both (WGET (w, pointm), buffer,
XFASTINT (charpos), XFASTINT (bytepos));
}
window_height_changed_p = resize_mini_window (w, 0);
/* Use the starting position chosen by resize_mini_window. */
- SET_TEXT_POS_FROM_MARKER (start, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
/* Display. */
clear_glyph_matrix (w->desired_matrix);
int
resize_mini_window (struct window *w, int exact_p)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int window_height_changed_p = 0;
eassert (MINI_WINDOW_P (w));
/* By default, start display at the beginning. */
- set_marker_both (WVAR (w, start), WVAR (w, buffer),
- BUF_BEGV (XBUFFER (WVAR (w, buffer))),
- BUF_BEGV_BYTE (XBUFFER (WVAR (w, buffer))));
+ set_marker_both (WGET (w, start), WGET (w, buffer),
+ BUF_BEGV (XBUFFER (WGET (w, buffer))),
+ BUF_BEGV_BYTE (XBUFFER (WGET (w, buffer))));
/* Don't resize windows while redisplaying a window; it would
confuse redisplay functions when the size of the window they are
struct text_pos start;
struct buffer *old_current_buffer = NULL;
- if (current_buffer != XBUFFER (WVAR (w, buffer)))
+ if (current_buffer != XBUFFER (WGET (w, buffer)))
{
old_current_buffer = current_buffer;
- set_buffer_internal (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal (XBUFFER (WGET (w, buffer)));
}
init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
}
else
SET_TEXT_POS (start, BEGV, BEGV_BYTE);
- SET_MARKER_FROM_TEXT_POS (WVAR (w, start), start);
+ SET_MARKER_FROM_TEXT_POS (WGET (w, start), start);
if (EQ (Vresize_mini_windows, Qgrow_only))
{
Fselect_window (FGET (f, selected_window), Qt);
set_buffer_internal_1
- (XBUFFER (WVAR (XWINDOW (FGET (f, selected_window)), buffer)));
+ (XBUFFER (WGET (XWINDOW (FGET (f, selected_window)), buffer)));
fmt = FRAME_ICONIFIED_P (f) ? Vicon_title_format : Vframe_title_format;
mode_line_target = MODE_LINE_TITLE;
&& FRAME_NS_P (f))
ns_set_doc_edited
(f, Fbuffer_modified_p
- (WVAR (XWINDOW (FGET (f, selected_window)), buffer)));
+ (WGET (XWINDOW (FGET (f, selected_window)), buffer)));
#endif
UNGCPRO;
}
/* This used to test w->update_mode_line, but we believe
there is no need to recompute the menu in that case. */
|| update_mode_lines
- || ((BUF_SAVE_MODIFF (XBUFFER (WVAR (w, buffer)))
- < BUF_MODIFF (XBUFFER (WVAR (w, buffer))))
+ || ((BUF_SAVE_MODIFF (XBUFFER (WGET (w, buffer)))
+ < BUF_MODIFF (XBUFFER (WGET (w, buffer))))
!= w->last_had_star)
|| ((!NILP (Vtransient_mark_mode)
- && !NILP (BVAR (XBUFFER (WVAR (w, buffer)), mark_active)))
- != !NILP (WVAR (w, region_showing))))
+ && !NILP (BVAR (XBUFFER (WGET (w, buffer)), mark_active)))
+ != !NILP (WGET (w, region_showing))))
{
struct buffer *prev = current_buffer;
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_menubar_update, Qt);
- set_buffer_internal_1 (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (w, buffer)));
if (save_match_data)
record_unwind_save_match_data ();
if (NILP (Voverriding_local_map_menu_flag))
if (windows_or_buffers_changed
|| w->update_mode_line
|| update_mode_lines
- || ((BUF_SAVE_MODIFF (XBUFFER (WVAR (w, buffer)))
- < BUF_MODIFF (XBUFFER (WVAR (w, buffer))))
+ || ((BUF_SAVE_MODIFF (XBUFFER (WGET (w, buffer)))
+ < BUF_MODIFF (XBUFFER (WGET (w, buffer))))
!= w->last_had_star)
|| ((!NILP (Vtransient_mark_mode)
- && !NILP (BVAR (XBUFFER (WVAR (w, buffer)), mark_active)))
- != !NILP (WVAR (w, region_showing))))
+ && !NILP (BVAR (XBUFFER (WGET (w, buffer)), mark_active)))
+ != !NILP (WGET (w, region_showing))))
{
struct buffer *prev = current_buffer;
ptrdiff_t count = SPECPDL_INDEX ();
/* Set current_buffer to the buffer of the selected
window of the frame, so that we get the right local
keymaps. */
- set_buffer_internal_1 (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (w, buffer)));
/* Save match data, if we must. */
if (save_match_data)
{
struct window *w = XWINDOW (window);
- if (WINDOWP (WVAR (w, hchild)))
- hscrolled_p |= hscroll_window_tree (WVAR (w, hchild));
- else if (WINDOWP (WVAR (w, vchild)))
- hscrolled_p |= hscroll_window_tree (WVAR (w, vchild));
+ if (WINDOWP (WGET (w, hchild)))
+ hscrolled_p |= hscroll_window_tree (WGET (w, hchild));
+ else if (WINDOWP (WGET (w, vchild)))
+ hscrolled_p |= hscroll_window_tree (WGET (w, vchild));
else if (w->cursor.vpos >= 0)
{
int h_margin;
/* Scroll when cursor is inside this scroll margin. */
h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
- if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, WVAR (w, buffer)))
+ if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, WGET (w, buffer)))
/* For left-to-right rows, hscroll when cursor is either
(i) inside the right hscroll margin, or (ii) if it is
inside the left margin and the window is already
/* Find point in a display of infinite width. */
saved_current_buffer = current_buffer;
- current_buffer = XBUFFER (WVAR (w, buffer));
+ current_buffer = XBUFFER (WGET (w, buffer));
if (w == XWINDOW (selected_window))
pt = PT;
else
{
- pt = marker_position (WVAR (w, pointm));
+ pt = marker_position (WGET (w, pointm));
pt = max (BEGV, pt);
pt = min (ZV, pt);
}
redisplay. */
if (w->hscroll != hscroll)
{
- XBUFFER (WVAR (w, buffer))->prevent_redisplay_optimizations_p = 1;
+ XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
w->hscroll = hscroll;
hscrolled_p = 1;
}
}
}
- window = WVAR (w, next);
+ window = WGET (w, next);
}
/* Value is non-zero if hscroll of any leaf window has been changed. */
if (trace_redisplay_p)
fprintf (stderr, "%p (%s): %s\n",
w,
- ((BUFFERP (WVAR (w, buffer))
- && STRINGP (BVAR (XBUFFER (WVAR (w, buffer)), name)))
- ? SSDATA (BVAR (XBUFFER (WVAR (w, buffer)), name))
+ ((BUFFERP (WGET (w, buffer))
+ && STRINGP (BVAR (XBUFFER (WGET (w, buffer)), name)))
+ ? SSDATA (BVAR (XBUFFER (WGET (w, buffer)), name))
: "no buffer"),
method + len);
}
require to redisplay the whole paragraph. It might be worthwhile
to find the paragraph limits and widen the range of redisplayed
lines to that, but for now just give up this optimization. */
- if (!NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_display_reordering))
- && NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_paragraph_direction)))
+ if (!NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_display_reordering))
+ && NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_paragraph_direction)))
unchanged_p = 0;
}
reconsider_clip_changes (struct window *w, struct buffer *b)
{
if (b->clip_changed
- && !NILP (WVAR (w, window_end_valid))
+ && !NILP (WGET (w, window_end_valid))
&& w->current_matrix->buffer == b
&& w->current_matrix->zv == BUF_ZV (b)
&& w->current_matrix->begv == BUF_BEGV (b))
b->clip_changed has already been set to 1, we can skip this
check. */
if (!b->clip_changed
- && BUFFERP (WVAR (w, buffer)) && !NILP (WVAR (w, window_end_valid)))
+ && BUFFERP (WGET (w, buffer)) && !NILP (WGET (w, window_end_valid)))
{
ptrdiff_t pt;
if (w == XWINDOW (selected_window))
pt = PT;
else
- pt = marker_position (WVAR (w, pointm));
+ pt = marker_position (WGET (w, pointm));
- if ((w->current_matrix->buffer != XBUFFER (WVAR (w, buffer))
+ if ((w->current_matrix->buffer != XBUFFER (WGET (w, buffer))
|| pt != w->last_point)
&& check_point_in_composition (w->current_matrix->buffer,
w->last_point,
- XBUFFER (WVAR (w, buffer)), pt))
+ XBUFFER (WGET (w, buffer)), pt))
b->clip_changed = 1;
}
}
/* Don't examine these until after testing Vinhibit_redisplay.
When Emacs is shutting down, perhaps because its connection to
X has dropped, we should not look at them at all. */
- fr = XFRAME (WVAR (w, frame));
+ fr = XFRAME (WGET (w, frame));
sf = SELECTED_FRAME ();
if (!fr->glyphs_initialized_p)
specbind (Qinhibit_point_motion_hooks, Qt);
/* If %c is in the mode line, update it if needed. */
- if (!NILP (WVAR (w, column_number_displayed))
+ if (!NILP (WGET (w, column_number_displayed))
/* This alternative quickly identifies a common case
where no change is needed. */
&& !(PT == w->last_point
&& w->last_modified >= MODIFF
&& w->last_overlay_modified >= OVERLAY_MODIFF)
- && (XFASTINT (WVAR (w, column_number_displayed)) != current_column ()))
+ && (XFASTINT (WGET (w, column_number_displayed)) != current_column ()))
w->update_mode_line = 1;
unbind_to (count1, Qnil);
- FRAME_SCROLL_BOTTOM_VPOS (XFRAME (WVAR (w, frame))) = -1;
+ FRAME_SCROLL_BOTTOM_VPOS (XFRAME (WGET (w, frame))) = -1;
/* The variable buffer_shared is set in redisplay_window and
indicates that we redisplay a buffer in different windows. See
the whole window. The assignment to this_line_start_pos prevents
the optimization directly below this if-statement. */
if (((!NILP (Vtransient_mark_mode)
- && !NILP (BVAR (XBUFFER (WVAR (w, buffer)), mark_active)))
- != !NILP (WVAR (w, region_showing)))
- || (!NILP (WVAR (w, region_showing))
- && !EQ (WVAR (w, region_showing),
- Fmarker_position (BVAR (XBUFFER (WVAR (w, buffer)), mark)))))
+ && !NILP (BVAR (XBUFFER (WGET (w, buffer)), mark_active)))
+ != !NILP (WGET (w, region_showing)))
+ || (!NILP (WGET (w, region_showing))
+ && !EQ (WGET (w, region_showing),
+ Fmarker_position (BVAR (XBUFFER (WGET (w, buffer)), mark)))))
CHARPOS (this_line_start_pos) = 0;
/* Optimize the case that only the line containing the cursor in the
&& !w->update_mode_line
&& !current_buffer->clip_changed
&& !current_buffer->prevent_redisplay_optimizations_p
- && FRAME_VISIBLE_P (XFRAME (WVAR (w, frame)))
- && !FRAME_OBSCURED_P (XFRAME (WVAR (w, frame)))
+ && FRAME_VISIBLE_P (XFRAME (WGET (w, frame)))
+ && !FRAME_OBSCURED_P (XFRAME (WGET (w, frame)))
/* Make sure recorded data applies to current buffer, etc. */
&& this_line_buffer == current_buffer
- && current_buffer == XBUFFER (WVAR (w, buffer))
+ && current_buffer == XBUFFER (WGET (w, buffer))
&& !w->force_start
&& !w->optional_new_start
/* Point must be on the line that we have info recorded about. */
adjusted. */
if ((it.glyph_row - 1)->displays_text_p)
{
- if (XFASTINT (WVAR (w, window_end_vpos)) < this_line_vpos)
- XSETINT (WVAR (w, window_end_vpos), this_line_vpos);
+ if (XFASTINT (WGET (w, window_end_vpos)) < this_line_vpos)
+ WSET (w, window_end_vpos, make_number (this_line_vpos));
}
- else if (XFASTINT (WVAR (w, window_end_vpos)) == this_line_vpos
+ else if (XFASTINT (WGET (w, window_end_vpos)) == this_line_vpos
&& this_line_vpos > 0)
- XSETINT (WVAR (w, window_end_vpos), this_line_vpos - 1);
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_vpos, make_number (this_line_vpos - 1));
+ WSET (w, window_end_valid, Qnil);
/* Update hint: No need to try to scroll in update_window. */
w->desired_matrix->no_scrolling_p = 1;
&& (EQ (selected_window,
BVAR (current_buffer, last_selected_window))
|| highlight_nonselected_windows)
- && NILP (WVAR (w, region_showing))
+ && NILP (WGET (w, region_showing))
&& NILP (Vshow_trailing_whitespace)
&& !cursor_in_echo_area)
{
Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
struct frame *mini_frame;
- displayed_buffer = XBUFFER (WVAR (XWINDOW (selected_window), buffer));
+ displayed_buffer = XBUFFER (WGET (XWINDOW (selected_window), buffer));
/* Use list_of_error, not Qerror, so that
we catch only errors and don't run the debugger. */
internal_condition_case_1 (redisplay_window_1, selected_window,
/* If we pause after scrolling, some rows in the current
matrices of some windows are not valid. */
if (!WINDOW_FULL_WIDTH_P (w)
- && !FRAME_WINDOW_P (XFRAME (WVAR (w, frame))))
+ && !FRAME_WINDOW_P (XFRAME (WGET (w, frame))))
update_mode_lines = 1;
}
else
static void
mark_window_display_accurate_1 (struct window *w, int accurate_p)
{
- if (BUFFERP (WVAR (w, buffer)))
+ if (BUFFERP (WGET (w, buffer)))
{
- struct buffer *b = XBUFFER (WVAR (w, buffer));
+ struct buffer *b = XBUFFER (WGET (w, buffer));
w->last_modified = accurate_p ? BUF_MODIFF(b) : 0;
w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF(b) : 0;
if (w == XWINDOW (selected_window))
w->last_point = BUF_PT (b);
else
- w->last_point = XMARKER (WVAR (w, pointm))->charpos;
+ w->last_point = XMARKER (WGET (w, pointm))->charpos;
}
}
if (accurate_p)
{
- WVAR (w, window_end_valid) = WVAR (w, buffer);
+ WSET (w, window_end_valid, WGET (w, buffer));
w->update_mode_line = 0;
}
}
{
struct window *w;
- for (; !NILP (window); window = WVAR (w, next))
+ for (; !NILP (window); window = WGET (w, next))
{
w = XWINDOW (window);
mark_window_display_accurate_1 (w, accurate_p);
- if (!NILP (WVAR (w, vchild)))
- mark_window_display_accurate (WVAR (w, vchild), accurate_p);
- if (!NILP (WVAR (w, hchild)))
- mark_window_display_accurate (WVAR (w, hchild), accurate_p);
+ if (!NILP (WGET (w, vchild)))
+ mark_window_display_accurate (WGET (w, vchild), accurate_p);
+ if (!NILP (WGET (w, hchild)))
+ mark_window_display_accurate (WGET (w, hchild), accurate_p);
}
if (accurate_p)
{
struct window *w = XWINDOW (window);
- if (!NILP (WVAR (w, hchild)))
- redisplay_windows (WVAR (w, hchild));
- else if (!NILP (WVAR (w, vchild)))
- redisplay_windows (WVAR (w, vchild));
- else if (!NILP (WVAR (w, buffer)))
+ if (!NILP (WGET (w, hchild)))
+ redisplay_windows (WGET (w, hchild));
+ else if (!NILP (WGET (w, vchild)))
+ redisplay_windows (WGET (w, vchild));
+ else if (!NILP (WGET (w, buffer)))
{
- displayed_buffer = XBUFFER (WVAR (w, buffer));
+ displayed_buffer = XBUFFER (WGET (w, buffer));
/* Use list_of_error, not Qerror, so that
we catch only errors and don't run the debugger. */
internal_condition_case_1 (redisplay_window_0, window,
redisplay_window_error);
}
- window = WVAR (w, next);
+ window = WGET (w, next);
}
}
&& !MATRIX_ROW_CONTINUATION_LINE_P (row)
&& row->x == 0)
{
- this_line_buffer = XBUFFER (WVAR (w, buffer));
+ this_line_buffer = XBUFFER (WGET (w, buffer));
CHARPOS (this_line_start_pos)
= MATRIX_ROW_START_CHARPOS (row) + delta;
run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
{
struct window *w = XWINDOW (window);
- SET_MARKER_FROM_TEXT_POS (WVAR (w, start), startp);
+ SET_MARKER_FROM_TEXT_POS (WGET (w, start), startp);
- if (current_buffer != XBUFFER (WVAR (w, buffer)))
+ if (current_buffer != XBUFFER (WGET (w, buffer)))
abort ();
if (!NILP (Vwindow_scroll_functions))
{
run_hook_with_args_2 (Qwindow_scroll_functions, window,
make_number (CHARPOS (startp)));
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
/* In case the hook functions switch buffers. */
- if (current_buffer != XBUFFER (WVAR (w, buffer)))
- set_buffer_internal_1 (XBUFFER (WVAR (w, buffer)));
+ if (current_buffer != XBUFFER (WGET (w, buffer)))
+ set_buffer_internal_1 (XBUFFER (WGET (w, buffer)));
}
return startp;
int temp_scroll_step, int last_line_misfit)
{
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct text_pos pos, startp;
struct it it;
int this_scroll_margin, scroll_max, rc, height;
debug_method_add (w, "try_scrolling");
#endif
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
/* Compute scroll margin height in pixels. We scroll when point is
within this distance from the top or bottom of the window. */
if (!just_this_one_p
|| current_buffer->clip_changed
|| BEG_UNCHANGED < CHARPOS (startp))
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_number, Qnil);
/* If cursor ends up on a partially visible line,
treat that as being off the bottom of the screen. */
struct text_pos pos, start_pos;
int window_start_changed_p = 0;
- SET_TEXT_POS_FROM_MARKER (start_pos, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (start_pos, WGET (w, start));
/* If window start is on a continuation line... Window start may be
< BEGV in case there's invisible text at the start of the
}
/* Set the window start there. */
- SET_MARKER_FROM_TEXT_POS (WVAR (w, start), pos);
+ SET_MARKER_FROM_TEXT_POS (WGET (w, start), pos);
window_start_changed_p = 1;
}
}
try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_step)
{
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
#ifdef GLYPH_DEBUG
set the cursor. */
&& !(!NILP (Vtransient_mark_mode)
&& !NILP (BVAR (current_buffer, mark_active)))
- && NILP (WVAR (w, region_showing))
+ && NILP (WGET (w, region_showing))
&& NILP (Vshow_trailing_whitespace)
/* This code is not used for mini-buffer for the sake of the case
of redisplaying to replace an echo area message; since in
larger than the window. This should really be fixed in
window.c. I don't have this on my list, now, so we do
approximately the same as the old redisplay code. --gerd. */
- && INTEGERP (WVAR (w, window_end_vpos))
- && XFASTINT (WVAR (w, window_end_vpos)) < w->current_matrix->nrows
+ && INTEGERP (WGET (w, window_end_vpos))
+ && XFASTINT (WGET (w, window_end_vpos)) < w->current_matrix->nrows
&& (FRAME_WINDOW_P (f)
|| !overlay_arrow_in_current_buffer_p ()))
{
must_scroll = 1;
}
else if (rc != CURSOR_MOVEMENT_SUCCESS
- && !NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_display_reordering)))
+ && !NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_display_reordering)))
{
struct glyph_row *row1;
else if (scroll_p)
rc = CURSOR_MOVEMENT_MUST_SCROLL;
else if (rc != CURSOR_MOVEMENT_SUCCESS
- && !NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_display_reordering)))
+ && !NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_display_reordering)))
{
/* With bidi-reordered rows, there could be more than
one candidate row whose start and end positions
|| (w == XWINDOW (minibuf_window)
&& NILP (echo_area_buffer[0])))
{
- struct buffer *buf = XBUFFER (WVAR (w, buffer));
+ struct buffer *buf = XBUFFER (WGET (w, buffer));
whole = BUF_ZV (buf) - BUF_BEGV (buf);
- start = marker_position (WVAR (w, start)) - BUF_BEGV (buf);
+ start = marker_position (WGET (w, start)) - BUF_BEGV (buf);
/* I don't think this is guaranteed to be right. For the
moment, we'll pretend it is. */
- end = BUF_Z (buf) - XFASTINT (WVAR (w, window_end_pos)) - BUF_BEGV (buf);
+ end = BUF_Z (buf) - XFASTINT (WGET (w, window_end_pos)) - BUF_BEGV (buf);
if (end < start)
end = start;
start = end = whole = 0;
/* Indicate what this scroll bar ought to be displaying now. */
- if (FRAME_TERMINAL (XFRAME (WVAR (w, frame)))->set_vertical_scroll_bar_hook)
- (*FRAME_TERMINAL (XFRAME (WVAR (w, frame)))->set_vertical_scroll_bar_hook)
+ if (FRAME_TERMINAL (XFRAME (WGET (w, frame)))->set_vertical_scroll_bar_hook)
+ (*FRAME_TERMINAL (XFRAME (WGET (w, frame)))->set_vertical_scroll_bar_hook)
(w, end - start, whole, start);
}
redisplay_window (Lisp_Object window, int just_this_one_p)
{
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
- struct buffer *buffer = XBUFFER (WVAR (w, buffer));
+ struct frame *f = XFRAME (WGET (w, frame));
+ struct buffer *buffer = XBUFFER (WGET (w, buffer));
struct buffer *old = current_buffer;
struct text_pos lpoint, opoint, startp;
int update_mode_line;
opoint = lpoint;
/* W must be a leaf window here. */
- eassert (!NILP (WVAR (w, buffer)));
+ eassert (!NILP (WGET (w, buffer)));
#ifdef GLYPH_DEBUG
*w->desired_matrix->method = 0;
#endif
else if ((w != XWINDOW (minibuf_window)
|| minibuf_level == 0)
/* When buffer is nonempty, redisplay window normally. */
- && BUF_Z (XBUFFER (WVAR (w, buffer))) == BUF_BEG (XBUFFER (WVAR (w, buffer)))
+ && BUF_Z (XBUFFER (WGET (w, buffer))) == BUF_BEG (XBUFFER (WGET (w, buffer)))
/* Quail displays non-mini buffers in minibuffer window.
In that case, redisplay the window normally. */
- && !NILP (Fmemq (WVAR (w, buffer), Vminibuffer_list)))
+ && !NILP (Fmemq (WGET (w, buffer), Vminibuffer_list)))
{
/* W is a mini-buffer window, but it's not active, so clear
it. */
value. */
/* Really select the buffer, for the sake of buffer-local
variables. */
- set_buffer_internal_1 (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (w, buffer)));
current_matrix_up_to_date_p
- = (!NILP (WVAR (w, window_end_valid))
+ = (!NILP (WGET (w, window_end_valid))
&& !current_buffer->clip_changed
&& !current_buffer->prevent_redisplay_optimizations_p
&& w->last_modified >= MODIFF
specbind (Qinhibit_point_motion_hooks, Qt);
buffer_unchanged_p
- = (!NILP (WVAR (w, window_end_valid))
+ = (!NILP (WGET (w, window_end_valid))
&& !current_buffer->clip_changed
&& w->last_modified >= MODIFF
&& w->last_overlay_modified >= OVERLAY_MODIFF);
{
/* If window starts on a continuation line, maybe adjust the
window start in case the window's width changed. */
- if (XMARKER (WVAR (w, start))->buffer == current_buffer)
+ if (XMARKER (WGET (w, start))->buffer == current_buffer)
compute_window_start_on_continuation_line (w);
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
}
/* Some sanity checks. */
abort ();
/* If %c is in mode line, update it if needed. */
- if (!NILP (WVAR (w, column_number_displayed))
+ if (!NILP (WGET (w, column_number_displayed))
/* This alternative quickly identifies a common case
where no change is needed. */
&& !(PT == w->last_point
&& w->last_modified >= MODIFF
&& w->last_overlay_modified >= OVERLAY_MODIFF)
- && (XFASTINT (WVAR (w, column_number_displayed)) != current_column ()))
+ && (XFASTINT (WGET (w, column_number_displayed)) != current_column ()))
update_mode_line = 1;
/* Count number of windows showing the selected buffer. An indirect
{
struct buffer *current_base, *window_base;
current_base = current_buffer;
- window_base = XBUFFER (WVAR (XWINDOW (selected_window), buffer));
+ window_base = XBUFFER (WGET (XWINDOW (selected_window), buffer));
if (current_base->base_buffer)
current_base = current_base->base_buffer;
if (window_base->base_buffer)
window, set up appropriate value. */
if (!EQ (window, selected_window))
{
- ptrdiff_t new_pt = XMARKER (WVAR (w, pointm))->charpos;
- ptrdiff_t new_pt_byte = marker_byte_position (WVAR (w, pointm));
+ ptrdiff_t new_pt = XMARKER (WGET (w, pointm))->charpos;
+ ptrdiff_t new_pt_byte = marker_byte_position (WGET (w, pointm));
if (new_pt < BEGV)
{
new_pt = BEGV;
new_pt_byte = BEGV_BYTE;
- set_marker_both (WVAR (w, pointm), Qnil, BEGV, BEGV_BYTE);
+ set_marker_both (WGET (w, pointm), Qnil, BEGV, BEGV_BYTE);
}
else if (new_pt > (ZV - 1))
{
new_pt = ZV;
new_pt_byte = ZV_BYTE;
- set_marker_both (WVAR (w, pointm), Qnil, ZV, ZV_BYTE);
+ set_marker_both (WGET (w, pointm), Qnil, ZV, ZV_BYTE);
}
/* We don't use SET_PT so that the point-motion hooks don't run. */
}
/* If window-start is screwed up, choose a new one. */
- if (XMARKER (WVAR (w, start))->buffer != current_buffer)
+ if (XMARKER (WGET (w, start))->buffer != current_buffer)
goto recenter;
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
/* If someone specified a new starting point but did not insist,
check whether it can be used. */
w->force_start = 0;
w->vscroll = 0;
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
/* Forget any recorded base line for line number display. */
if (!buffer_unchanged_p)
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_number, Qnil);
/* Redisplay the mode line. Select the buffer properly for that.
Also, run the hook window-scroll-functions
MATRIX_ROW_START_BYTEPOS (row));
if (w != XWINDOW (selected_window))
- set_marker_both (WVAR (w, pointm), Qnil, PT, PT_BYTE);
+ set_marker_both (WGET (w, pointm), Qnil, PT, PT_BYTE);
else if (current_buffer == old)
SET_TEXT_POS (lpoint, PT, PT_BYTE);
sets it. So, we need to check the return value of
compute_window_start_on_continuation_line. (See also
bug#197). */
- && XMARKER (WVAR (w, start))->buffer == current_buffer
+ && XMARKER (WGET (w, start))->buffer == current_buffer
&& compute_window_start_on_continuation_line (w)
/* It doesn't make sense to force the window start like we
do at label force_start if it is already known that point
&& pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &d6))
{
w->force_start = 1;
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
goto force_start;
}
|| current_buffer->clip_changed
|| BEG_UNCHANGED < CHARPOS (startp))
/* Forget any recorded base line for line number display. */
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_number, Qnil);
if (!cursor_row_fully_visible_p (w, 1, 0))
{
/* Forget any previously recorded base line for line number display. */
if (!buffer_unchanged_p)
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_number, Qnil);
/* Determine the window start relative to point. */
init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
/* Set the window start position here explicitly, to avoid an
infinite loop in case the functions in window-scroll-functions
get errors. */
- set_marker_both (WVAR (w, start), Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
+ set_marker_both (WGET (w, start), Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
/* Run scroll hooks. */
startp = run_window_scroll_functions (window, it.current.pos);
line.) */
if (w->cursor.vpos < 0)
{
- if (!NILP (WVAR (w, window_end_valid))
- && PT >= Z - XFASTINT (WVAR (w, window_end_pos)))
+ if (!NILP (WGET (w, window_end_valid))
+ && PT >= Z - XFASTINT (WGET (w, window_end_pos)))
{
clear_glyph_matrix (w->desired_matrix);
move_it_by_lines (&it, 1);
done:
- SET_TEXT_POS_FROM_MARKER (startp, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
w->start_at_line_beg = (CHARPOS (startp) == BEGV
|| FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
&& !FRAME_WINDOW_P (f)
&& !WINDOW_FULL_WIDTH_P (w))
/* Line number to display. */
- || INTEGERP (WVAR (w, base_line_pos))
+ || INTEGERP (WGET (w, base_line_pos))
/* Column number is displayed and different from the one displayed. */
- || (!NILP (WVAR (w, column_number_displayed))
- && (XFASTINT (WVAR (w, column_number_displayed)) != current_column ())))
+ || (!NILP (WGET (w, column_number_displayed))
+ && (XFASTINT (WGET (w, column_number_displayed)) != current_column ())))
/* This means that the window has a mode line. */
&& (WINDOW_WANTS_MODELINE_P (w)
|| WINDOW_WANTS_HEADER_LINE_P (w)))
}
if (!line_number_displayed
- && !BUFFERP (WVAR (w, base_line_pos)))
+ && !BUFFERP (WGET (w, base_line_pos)))
{
- WVAR (w, base_line_pos) = Qnil;
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_pos, Qnil);
+ WSET (w, base_line_number, Qnil);
}
finish_menu_bars:
struct window *w = XWINDOW (window);
struct it it;
struct glyph_row *last_text_row = NULL;
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
/* Make POS the new window start. */
- set_marker_both (WVAR (w, start), Qnil, CHARPOS (pos), BYTEPOS (pos));
+ set_marker_both (WGET (w, start), Qnil, CHARPOS (pos), BYTEPOS (pos));
/* Mark cursor position as unknown. No overlay arrow seen. */
w->cursor.vpos = -1;
}
/* If bottom moved off end of frame, change mode line percentage. */
- if (XFASTINT (WVAR (w, window_end_pos)) <= 0
+ if (XFASTINT (WGET (w, window_end_pos)) <= 0
&& Z != IT_CHARPOS (it))
w->update_mode_line = 1;
eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
eassert
(MATRIX_ROW (w->desired_matrix,
- XFASTINT (WVAR (w, window_end_vpos)))->displays_text_p);
+ XFASTINT (WGET (w, window_end_vpos)))->displays_text_p);
}
else
{
w->window_end_bytepos = Z_BYTE - ZV_BYTE;
- WVAR (w, window_end_pos) = make_number (Z - ZV);
- WVAR (w, window_end_vpos) = make_number (0);
+ WSET (w, window_end_pos, make_number (Z - ZV));
+ WSET (w, window_end_vpos, make_number (0));
}
/* But that is not valid info until redisplay finishes. */
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
return 1;
}
static int
try_window_reusing_current_matrix (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph_row *bottom_row;
struct it it;
struct run run;
/* Can't do this if region may have changed. */
if ((!NILP (Vtransient_mark_mode)
&& !NILP (BVAR (current_buffer, mark_active)))
- || !NILP (WVAR (w, region_showing))
+ || !NILP (WGET (w, region_showing))
|| !NILP (Vshow_trailing_whitespace))
return 0;
/* The variable new_start now holds the new window start. The old
start `start' can be determined from the current matrix. */
- SET_TEXT_POS_FROM_MARKER (new_start, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (new_start, WGET (w, start));
start = start_row->minpos;
start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
{
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (last_reused_text_row,
- w->current_matrix));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row)));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (last_reused_text_row, w->current_matrix)));
}
else if (last_text_row)
{
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
}
else
{
/* This window must be completely empty. */
w->window_end_bytepos = Z_BYTE - ZV_BYTE;
- WVAR (w, window_end_pos) = make_number (Z - ZV);
- WVAR (w, window_end_vpos) = make_number (0);
+ WSET (w, window_end_pos, make_number (Z - ZV));
+ WSET (w, window_end_vpos, make_number (0));
}
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
/* Update hint: don't try scrolling again in update_window. */
w->desired_matrix->no_scrolling_p = 1;
/* Can't use this optimization with bidi-reordered glyph
rows, unless cursor is already at point. */
- if (!NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_display_reordering)))
+ if (!NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_display_reordering)))
{
if (!(w->cursor.hpos >= 0
&& w->cursor.hpos < row->used[TEXT_AREA]
{
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
}
else
{
- WVAR (w, window_end_vpos)
- = make_number (XFASTINT (WVAR (w, window_end_vpos)) - nrows_scrolled);
+ WSET (w, window_end_vpos,
+ make_number (XFASTINT (WGET (w, window_end_vpos)) - nrows_scrolled));
}
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
w->desired_matrix->no_scrolling_p = 1;
#ifdef GLYPH_DEBUG
/* Display must not have been paused, otherwise the current matrix
is not up to date. */
- eassert (!NILP (WVAR (w, window_end_valid)));
+ eassert (!NILP (WGET (w, window_end_valid)));
/* A value of window_end_pos >= END_UNCHANGED means that the window
end is in the range of changed text. If so, there is no
unchanged row at the end of W's current matrix. */
- if (XFASTINT (WVAR (w, window_end_pos)) >= END_UNCHANGED)
+ if (XFASTINT (WGET (w, window_end_pos)) >= END_UNCHANGED)
return NULL;
/* Set row to the last row in W's current matrix displaying text. */
- row = MATRIX_ROW (w->current_matrix, XFASTINT (WVAR (w, window_end_vpos)));
+ row = MATRIX_ROW (w->current_matrix, XFASTINT (WGET (w, window_end_vpos)));
/* If matrix is entirely empty, no unchanged row exists. */
if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
buffer positions in the current matrix to current buffer
positions for characters not in changed text. */
ptrdiff_t Z_old =
- MATRIX_ROW_END_CHARPOS (row) + XFASTINT (WVAR (w, window_end_pos));
+ MATRIX_ROW_END_CHARPOS (row) + XFASTINT (WGET (w, window_end_pos));
ptrdiff_t Z_BYTE_old =
MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
ptrdiff_t last_unchanged_pos, last_unchanged_pos_old;
static void
sync_frame_with_window_matrix_rows (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph_row *window_row, *window_row_end, *frame_row;
/* Preconditions: W must be a leaf window and full-width. Its frame
must have a frame matrix. */
- eassert (NILP (WVAR (w, hchild)) && NILP (WVAR (w, vchild)));
+ eassert (NILP (WGET (w, hchild)) && NILP (WGET (w, vchild)));
eassert (WINDOW_FULL_WIDTH_P (w));
eassert (!FRAME_WINDOW_P (f));
{
struct glyph_row *row = start;
struct glyph_row *best_row = NULL;
- ptrdiff_t mindif = BUF_ZV (XBUFFER (WVAR (w, buffer))) + 1;
+ ptrdiff_t mindif = BUF_ZV (XBUFFER (WGET (w, buffer))) + 1;
int last_y;
/* If we happen to start on a header-line, skip that. */
{
struct glyph *g;
- if (NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_display_reordering))
+ if (NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_display_reordering))
|| (!best_row && !row->continued_p))
return row;
/* In bidi-reordered rows, there could be several rows
static int
try_window_id (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph_matrix *current_matrix = w->current_matrix;
struct glyph_matrix *desired_matrix = w->desired_matrix;
struct glyph_row *last_unchanged_at_beg_row;
#define GIVE_UP(X) return 0
#endif
- SET_TEXT_POS_FROM_MARKER (start, WVAR (w, start));
+ SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
/* Don't use this for mini-windows because these can show
messages and mini-buffers, and we don't handle that here. */
GIVE_UP (7);
/* Verify that display wasn't paused. */
- if (NILP (WVAR (w, window_end_valid)))
+ if (NILP (WGET (w, window_end_valid)))
GIVE_UP (8);
/* Can't use this if highlighting a region because a cursor movement
GIVE_UP (11);
/* Likewise if showing a region. */
- if (!NILP (WVAR (w, region_showing)))
+ if (!NILP (WGET (w, region_showing)))
GIVE_UP (10);
/* Can't use this if overlay arrow position and/or string have
wrapped line can change the wrap position, altering the line
above it. It might be worthwhile to handle this more
intelligently, but for now just redisplay from scratch. */
- if (!NILP (BVAR (XBUFFER (WVAR (w, buffer)), word_wrap)))
+ if (!NILP (BVAR (XBUFFER (WGET (w, buffer)), word_wrap)))
GIVE_UP (21);
/* Under bidi reordering, adding or deleting a character in the
to find the paragraph limits and widen the range of redisplayed
lines to that, but for now just give up this optimization and
redisplay from scratch. */
- if (!NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_display_reordering))
- && NILP (BVAR (XBUFFER (WVAR (w, buffer)), bidi_paragraph_direction)))
+ if (!NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_display_reordering))
+ && NILP (BVAR (XBUFFER (WGET (w, buffer)), bidi_paragraph_direction)))
GIVE_UP (22);
/* Make sure beg_unchanged and end_unchanged are up to date. Do it
This case happens with stealth-fontification. Note that although
the display is unchanged, glyph positions in the matrix have to
be adjusted, of course. */
- row = MATRIX_ROW (w->current_matrix, XFASTINT (WVAR (w, window_end_vpos)));
+ row = MATRIX_ROW (w->current_matrix, XFASTINT (WGET (w, window_end_vpos)));
if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
&& ((last_changed_charpos < CHARPOS (start)
&& CHARPOS (start) == BEGV)
/* Compute how many chars/bytes have been added to or removed
from the buffer. */
- Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (WVAR (w, window_end_pos));
+ Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (WGET (w, window_end_pos));
Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
Z_delta = Z - Z_old;
Z_delta_bytes = Z_BYTE - Z_BYTE_old;
{
/* We have to compute the window end anew since text
could have been added/removed after it. */
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
/* Give up if the window ends in strings. Overlay strings
at the end are difficult to handle, so don't try. */
- row = MATRIX_ROW (current_matrix, XFASTINT (WVAR (w, window_end_vpos)));
+ row = MATRIX_ROW (current_matrix, XFASTINT (WGET (w, window_end_vpos)));
if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
GIVE_UP (20);
/* Set last_row to the glyph row in the current matrix where the
window end line is found. It has been moved up or down in
the matrix by dvpos. */
- int last_vpos = XFASTINT (WVAR (w, window_end_vpos)) + dvpos;
+ int last_vpos = XFASTINT (WGET (w, window_end_vpos)) + dvpos;
struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
/* If last_row is the window end line, it should display text. */
first_unchanged_at_end_row);
eassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
- WVAR (w, window_end_pos) = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
+ WSET (w, window_end_pos, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (row, w->current_matrix));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (row, w->current_matrix)));
eassert (w->window_end_bytepos >= 0);
IF_DEBUG (debug_method_add (w, "A"));
}
else if (last_text_row_at_end)
{
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end)));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix)));
eassert (w->window_end_bytepos >= 0);
IF_DEBUG (debug_method_add (w, "B"));
}
/* We have displayed either to the end of the window or at the
end of the window, i.e. the last row with text is to be found
in the desired matrix. */
- WVAR (w, window_end_pos)
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
+ WSET (w, window_end_pos,
+ make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
- WVAR (w, window_end_vpos)
- = make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
+ WSET (w, window_end_vpos,
+ make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix)));
eassert (w->window_end_bytepos >= 0);
}
else if (first_unchanged_at_end_row == NULL
/* Displayed to end of window, but no line containing text was
displayed. Lines were deleted at the end of the window. */
int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
- int vpos = XFASTINT (WVAR (w, window_end_vpos));
+ int vpos = XFASTINT (WGET (w, window_end_vpos));
struct glyph_row *current_row = current_matrix->rows + vpos;
struct glyph_row *desired_row = desired_matrix->rows + vpos;
}
eassert (row != NULL);
- WVAR (w, window_end_vpos) = make_number (vpos + 1);
- WVAR (w, window_end_pos) = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
+ WSET (w, window_end_vpos, make_number (vpos + 1));
+ WSET (w, window_end_pos, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
eassert (w->window_end_bytepos >= 0);
IF_DEBUG (debug_method_add (w, "C"));
else
abort ();
- IF_DEBUG (debug_end_pos = XFASTINT (WVAR (w, window_end_pos));
- debug_end_vpos = XFASTINT (WVAR (w, window_end_vpos)));
+ IF_DEBUG (debug_end_pos = XFASTINT (WGET (w, window_end_pos));
+ debug_end_vpos = XFASTINT (WGET (w, window_end_vpos)));
/* Record that display has not been completed. */
- WVAR (w, window_end_valid) = Qnil;
+ WSET (w, window_end_valid, Qnil);
w->desired_matrix->no_scrolling_p = 1;
return 3;
(Lisp_Object glyphs)
{
struct window *w = XWINDOW (selected_window);
- struct buffer *buffer = XBUFFER (WVAR (w, buffer));
+ struct buffer *buffer = XBUFFER (WGET (w, buffer));
fprintf (stderr, "PT = %"pI"d, BEGV = %"pI"d. ZV = %"pI"d\n",
BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
- struct buffer *buffer = XBUFFER (WVAR (w, buffer));
+ struct buffer *buffer = XBUFFER (WGET (w, buffer));
struct buffer *old = current_buffer;
const unsigned char *arrow_string = SDATA (overlay_arrow_string);
int arrow_len = SCHARS (overlay_arrow_string);
}
/* Is IT->w showing the region? */
- WVAR (it->w, region_showing) = it->region_beg_charpos > 0 ? Qt : Qnil;
+ WSET (it->w, region_showing, it->region_beg_charpos > 0 ? Qt : Qnil);
/* Clear the result glyph row and enable it. */
prepare_desired_row (row);
row->glyphs[TEXT_AREA]->charpos = -1;
row->displays_text_p = 0;
- if (!NILP (BVAR (XBUFFER (WVAR (it->w, buffer)), indicate_empty_lines))
+ if (!NILP (BVAR (XBUFFER (WGET (it->w, buffer)), indicate_empty_lines))
&& (!MINI_WINDOW_P (it->w)
|| (minibuf_level && EQ (it->window, minibuf_window))))
row->indicate_empty_line_p = 1;
{
struct window *w = XWINDOW (window);
- if (WINDOWP (WVAR (w, hchild)))
- nwindows += redisplay_mode_lines (WVAR (w, hchild), force);
- else if (WINDOWP (WVAR (w, vchild)))
- nwindows += redisplay_mode_lines (WVAR (w, vchild), force);
+ if (WINDOWP (WGET (w, hchild)))
+ nwindows += redisplay_mode_lines (WGET (w, hchild), force);
+ else if (WINDOWP (WGET (w, vchild)))
+ nwindows += redisplay_mode_lines (WGET (w, vchild), force);
else if (force
- || FRAME_GARBAGED_P (XFRAME (WVAR (w, frame)))
+ || FRAME_GARBAGED_P (XFRAME (WGET (w, frame)))
|| !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
{
struct text_pos lpoint;
/* Set the window's buffer for the mode line display. */
SET_TEXT_POS (lpoint, PT, PT_BYTE);
- set_buffer_internal_1 (XBUFFER (WVAR (w, buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (w, buffer)));
/* Point refers normally to the selected window. For any
other window, set up appropriate value. */
{
struct text_pos pt;
- SET_TEXT_POS_FROM_MARKER (pt, WVAR (w, pointm));
+ SET_TEXT_POS_FROM_MARKER (pt, WGET (w, pointm));
if (CHARPOS (pt) < BEGV)
TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
else if (CHARPOS (pt) > (ZV - 1))
TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
}
- window = WVAR (w, next);
+ window = WGET (w, next);
}
return nwindows;
int n = 0;
old_selected_frame = selected_frame;
- selected_frame = WVAR (w, frame);
+ selected_frame = WGET (w, frame);
old_selected_window = selected_window;
XSETWINDOW (selected_window, w);
/* These will be set while the mode line specs are processed. */
line_number_displayed = 0;
- WVAR (w, column_number_displayed) = Qnil;
+ WSET (w, column_number_displayed, Qnil);
if (WINDOW_WANTS_MODELINE_P (w))
{
w = XWINDOW (window);
if (NILP (buffer))
- buffer = WVAR (w, buffer);
+ buffer = WGET (w, buffer);
CHECK_BUFFER (buffer);
/* Make formatting the modeline a non-op when noninteractive, otherwise
else
{
ptrdiff_t col = current_column ();
- WVAR (w, column_number_displayed) = make_number (col);
+ WSET (w, column_number_displayed, make_number (col));
pint2str (decode_mode_spec_buf, field_width, col);
return decode_mode_spec_buf;
}
if (mode_line_target == MODE_LINE_TITLE)
return "";
- startpos = XMARKER (WVAR (w, start))->charpos;
- startpos_byte = marker_byte_position (WVAR (w, start));
+ startpos = XMARKER (WGET (w, start))->charpos;
+ startpos_byte = marker_byte_position (WGET (w, start));
height = WINDOW_TOTAL_LINES (w);
/* If we decided that this buffer isn't suitable for line numbers,
don't forget that too fast. */
- if (EQ (WVAR (w, base_line_pos), WVAR (w, buffer)))
+ if (EQ (WGET (w, base_line_pos), WGET (w, buffer)))
goto no_value;
/* But do forget it, if the window shows a different buffer now. */
- else if (BUFFERP (WVAR (w, base_line_pos)))
- WVAR (w, base_line_pos) = Qnil;
+ else if (BUFFERP (WGET (w, base_line_pos)))
+ WSET (w, base_line_pos, Qnil);
/* If the buffer is very big, don't waste time. */
if (INTEGERP (Vline_number_display_limit)
&& BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
{
- WVAR (w, base_line_pos) = Qnil;
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_pos, Qnil);
+ WSET (w, base_line_number, Qnil);
goto no_value;
}
- if (INTEGERP (WVAR (w, base_line_number))
- && INTEGERP (WVAR (w, base_line_pos))
- && XFASTINT (WVAR (w, base_line_pos)) <= startpos)
+ if (INTEGERP (WGET (w, base_line_number))
+ && INTEGERP (WGET (w, base_line_pos))
+ && XFASTINT (WGET (w, base_line_pos)) <= startpos)
{
- line = XFASTINT (WVAR (w, base_line_number));
- linepos = XFASTINT (WVAR (w, base_line_pos));
+ line = XFASTINT (WGET (w, base_line_number));
+ linepos = XFASTINT (WGET (w, base_line_pos));
linepos_byte = buf_charpos_to_bytepos (b, linepos);
}
else
go back past it. */
if (startpos == BUF_BEGV (b))
{
- WVAR (w, base_line_number) = make_number (topline);
- WVAR (w, base_line_pos) = make_number (BUF_BEGV (b));
+ WSET (w, base_line_number, make_number (topline));
+ WSET (w, base_line_pos, make_number (BUF_BEGV (b)));
}
else if (nlines < height + 25 || nlines > height * 3 + 50
|| linepos == BUF_BEGV (b))
give up on line numbers for this window. */
if (position == limit_byte && limit == startpos - distance)
{
- WVAR (w, base_line_pos) = WVAR (w, buffer);
- WVAR (w, base_line_number) = Qnil;
+ WSET (w, base_line_pos, WGET (w, buffer));
+ WSET (w, base_line_number, Qnil);
goto no_value;
}
- WVAR (w, base_line_number) = make_number (topline - nlines);
- WVAR (w, base_line_pos) = make_number (BYTE_TO_CHAR (position));
+ WSET (w, base_line_number, make_number (topline - nlines));
+ WSET (w, base_line_pos, make_number (BYTE_TO_CHAR (position)));
}
/* Now count lines from the start pos to point. */
case 'p':
{
- ptrdiff_t pos = marker_position (WVAR (w, start));
+ ptrdiff_t pos = marker_position (WGET (w, start));
ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b);
- if (XFASTINT (WVAR (w, window_end_pos)) <= BUF_Z (b) - BUF_ZV (b))
+ if (XFASTINT (WGET (w, window_end_pos)) <= BUF_Z (b) - BUF_ZV (b))
{
if (pos <= BUF_BEGV (b))
return "All";
/* Display percentage of size above the bottom of the screen. */
case 'P':
{
- ptrdiff_t toppos = marker_position (WVAR (w, start));
- ptrdiff_t botpos = BUF_Z (b) - XFASTINT (WVAR (w, window_end_pos));
+ ptrdiff_t toppos = marker_position (WGET (w, start));
+ ptrdiff_t botpos = BUF_Z (b) - XFASTINT (WGET (w, window_end_pos));
ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b);
if (botpos >= BUF_ZV (b))
return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
}
- prop = buffer_local_value_1 (prop, WVAR (it->w, buffer));
+ prop = buffer_local_value_1 (prop, WGET (it->w, buffer));
if (EQ (prop, Qunbound))
prop = Qnil;
}
return OK_PIXELS (pixels);
}
- car = buffer_local_value_1 (car, WVAR (it->w, buffer));
+ car = buffer_local_value_1 (car, WGET (it->w, buffer));
if (EQ (car, Qunbound))
car = Qnil;
}
{
memset (s, 0, sizeof *s);
s->w = w;
- s->f = XFRAME (WVAR (w, frame));
+ s->f = XFRAME (WGET (w, frame));
#ifdef HAVE_NTGUI
s->hdc = hdc;
#endif
int voffset;
int glyph_not_available_p;
- eassert (s->f == XFRAME (WVAR (s->w, frame)));
+ eassert (s->f == XFRAME (WGET (s->w, frame)));
eassert (s->nchars == 0);
eassert (start >= 0 && end > start);
int n = width;
if (!STRINGP (object))
- object = WVAR (it->w, buffer);
+ object = WGET (it->w, buffer);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (it->f))
append_stretch_glyph (it, object, width, height, ascent);
int from_x, from_y, to_y;
eassert (updated_window && updated_row);
- f = XFRAME (WVAR (w, frame));
+ f = XFRAME (WGET (w, frame));
if (updated_row->full_width_p)
max_x = WINDOW_TOTAL_WIDTH (w);
get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
int *active_cursor)
{
- struct frame *f = XFRAME (WVAR (w, frame));
- struct buffer *b = XBUFFER (WVAR (w, buffer));
+ struct frame *f = XFRAME (WGET (w, frame));
+ struct buffer *b = XBUFFER (WGET (w, buffer));
int cursor_type = DEFAULT_CURSOR;
Lisp_Object alt_cursor;
int non_selected = 0;
void
erase_phys_cursor (struct window *w)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
int hpos = w->phys_cursor.hpos;
int vpos = w->phys_cursor.vpos;
display_and_set_cursor (struct window *w, int on,
int hpos, int vpos, int x, int y)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int new_cursor_type;
int new_cursor_width;
int active_cursor;
{
while (w)
{
- if (!NILP (WVAR (w, hchild)))
- update_cursor_in_window_tree (XWINDOW (WVAR (w, hchild)), on_p);
- else if (!NILP (WVAR (w, vchild)))
- update_cursor_in_window_tree (XWINDOW (WVAR (w, vchild)), on_p);
+ if (!NILP (WGET (w, hchild)))
+ update_cursor_in_window_tree (XWINDOW (WGET (w, hchild)), on_p);
+ else if (!NILP (WGET (w, vchild)))
+ update_cursor_in_window_tree (XWINDOW (WGET (w, vchild)), on_p);
else
update_window_cursor (w, on_p);
- w = NILP (WVAR (w, next)) ? 0 : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
}
}
void
x_clear_cursor (struct window *w)
{
- if (FRAME_VISIBLE_P (XFRAME (WVAR (w, frame))) && w->phys_cursor_on_p)
+ if (FRAME_VISIBLE_P (XFRAME (WGET (w, frame))) && w->phys_cursor_on_p)
update_window_cursor (w, 0);
}
enum draw_glyphs_face draw)
{
#ifdef HAVE_WINDOW_SYSTEM
- if (FRAME_WINDOW_P (XFRAME (WVAR (w, frame))))
+ if (FRAME_WINDOW_P (XFRAME (WGET (w, frame))))
{
draw_glyphs (w, start_x, row, TEXT_AREA, start_hpos, end_hpos, draw, 0);
return;
static int
coords_in_mouse_face_p (struct window *w, int hpos, int vpos)
{
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WVAR (w, frame)));
+ Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WGET (w, frame)));
/* Quickly resolve the easy cases. */
if (!(WINDOWP (hlinfo->mouse_face_window)
/* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
rows_from_pos_range (w, start_charpos, end_charpos, disp_string, &r1, &r2);
if (r1 == NULL)
- r1 = MATRIX_ROW (w->current_matrix, XFASTINT (WVAR (w, window_end_vpos)));
+ r1 = MATRIX_ROW (w->current_matrix, XFASTINT (WGET (w, window_end_vpos)));
/* If the before-string or display-string contains newlines,
rows_from_pos_range skips to its last row. Move back. */
if (!NILP (before_string) || !NILP (disp_string))
}
if (r2 == NULL)
{
- r2 = MATRIX_ROW (w->current_matrix, XFASTINT (WVAR (w, window_end_vpos)));
+ r2 = MATRIX_ROW (w->current_matrix, XFASTINT (WGET (w, window_end_vpos)));
hlinfo->mouse_face_past_end = 1;
}
else if (!NILP (after_string))
/* If the after-string has newlines, advance to its last row. */
struct glyph_row *next;
struct glyph_row *last
- = MATRIX_ROW (w->current_matrix, XFASTINT (WVAR (w, window_end_vpos)));
+ = MATRIX_ROW (w->current_matrix, XFASTINT (WGET (w, window_end_vpos)));
for (next = r2 + 1;
next <= last
enum window_part area)
{
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
#ifdef HAVE_WINDOW_SYSTEM
Display_Info *dpyinfo;
{
help_echo_string = help;
XSETWINDOW (help_echo_window, w);
- help_echo_object = WVAR (w, buffer);
+ help_echo_object = WGET (w, buffer);
help_echo_pos = charpos;
}
}
{
Lisp_Object default_help
= buffer_local_value_1 (Qmode_line_default_help_echo,
- WVAR (w, buffer));
+ WGET (w, buffer));
if (STRINGP (default_help))
{
/* Are we in a window whose display is up to date?
And verify the buffer's text has not changed. */
- b = XBUFFER (WVAR (w, buffer));
+ b = XBUFFER (WGET (w, buffer));
if (part == ON_TEXT
- && EQ (WVAR (w, window_end_valid), WVAR (w, buffer))
+ && EQ (WGET (w, window_end_valid), WGET (w, buffer))
&& w->last_modified == BUF_MODIFF (b)
&& w->last_overlay_modified == BUF_OVERLAY_MODIFF (b))
{
if (pos > 0)
{
mouse_face = get_char_property_and_overlay
- (make_number (pos), Qmouse_face, WVAR (w, buffer), &overlay);
- buffer = WVAR (w, buffer);
+ (make_number (pos), Qmouse_face, WGET (w, buffer), &overlay);
+ buffer = WGET (w, buffer);
disp_string = object;
}
}
is the smallest. */
Lisp_Object lim1 =
NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
- ? Fmarker_position (WVAR (w, start))
+ ? Fmarker_position (WGET (w, start))
: Qnil;
Lisp_Object lim2 =
NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
? make_number (BUF_Z (XBUFFER (buffer))
- - XFASTINT (WVAR (w, window_end_pos)))
+ - XFASTINT (WGET (w, window_end_pos)))
: Qnil;
if (NILP (overlay))
if (p > 0)
{
help = Fget_char_property (make_number (p),
- Qhelp_echo, WVAR (w, buffer));
+ Qhelp_echo, WGET (w, buffer));
if (!NILP (help))
{
charpos = p;
- obj = WVAR (w, buffer);
+ obj = WGET (w, buffer);
}
}
}
ptrdiff_t p = string_buffer_position (obj, start);
if (p > 0)
pointer = Fget_char_property (make_number (p),
- Qpointer, WVAR (w, buffer));
+ Qpointer, WGET (w, buffer));
}
}
else if (BUFFERP (obj)
void
x_clear_window_mouse_face (struct window *w)
{
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WVAR (w, frame)));
+ Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WGET (w, frame)));
Lisp_Object window;
BLOCK_INPUT;
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
window = hlinfo->mouse_face_window;
- if (! NILP (window) && XFRAME (WVAR (XWINDOW (window), frame)) == f)
+ if (! NILP (window) && XFRAME (WGET (XWINDOW (window), frame)) == f)
{
hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
do it for frames with vertical scroll bars because either the
right scroll bar of a window, or the left scroll bar of its
neighbor will suffice as a border. */
- if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WVAR (w, frame))))
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WGET (w, frame))))
return;
if (!WINDOW_RIGHTMOST_P (w)
static int
expose_window (struct window *w, XRectangle *fr)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
XRectangle wr, r;
int mouse_face_overwritten_p = 0;
static int
expose_window_tree (struct window *w, XRectangle *r)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int mouse_face_overwritten_p = 0;
while (w && !FRAME_GARBAGED_P (f))
{
- if (!NILP (WVAR (w, hchild)))
+ if (!NILP (WGET (w, hchild)))
mouse_face_overwritten_p
- |= expose_window_tree (XWINDOW (WVAR (w, hchild)), r);
- else if (!NILP (WVAR (w, vchild)))
+ |= expose_window_tree (XWINDOW (WGET (w, hchild)), r);
+ else if (!NILP (WGET (w, vchild)))
mouse_face_overwritten_p
- |= expose_window_tree (XWINDOW (WVAR (w, vchild)), r);
+ |= expose_window_tree (XWINDOW (WGET (w, vchild)), r);
else
mouse_face_overwritten_p |= expose_window (w, r);
- w = NILP (WVAR (w, next)) ? NULL : XWINDOW (WVAR (w, next));
+ w = NILP (WGET (w, next)) ? NULL : XWINDOW (WGET (w, next));
}
return mouse_face_overwritten_p;
if (!noninteractive)
{
struct window *m = XWINDOW (minibuf_window);
- Lisp_Object frame = WVAR (m, frame);
+ Lisp_Object frame = WGET (m, frame);
struct frame *f = XFRAME (frame);
Lisp_Object root = FRAME_ROOT_WINDOW (f);
struct window *r = XWINDOW (root);
echo_area_window = minibuf_window;
- XSETFASTINT (WVAR (r, top_line), FRAME_TOP_MARGIN (f));
- XSETFASTINT (WVAR (r, total_lines), FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f));
- XSETFASTINT (WVAR (r, total_cols), FRAME_COLS (f));
- XSETFASTINT (WVAR (m, top_line), FRAME_LINES (f) - 1);
- XSETFASTINT (WVAR (m, total_lines), 1);
- XSETFASTINT (WVAR (m, total_cols), FRAME_COLS (f));
+ WSET (r, top_line, make_number (FRAME_TOP_MARGIN (f)));
+ WSET (r, total_lines, make_number (FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f)));
+ WSET (r, total_cols, make_number (FRAME_COLS (f)));
+ WSET (m, top_line, make_number (FRAME_LINES (f) - 1));
+ WSET (m, total_lines, make_number (1));
+ WSET (m, total_cols, make_number (FRAME_COLS (f)));
scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
scratch_glyph_row.glyphs[TEXT_AREA + 1]
ptrdiff_t *endptr, ptrdiff_t limit,
int mouse, int base_face_id)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object prop, position;
ptrdiff_t i, noverlays;
/* Get the `face' or `mouse_face' text property at POS, and
determine the next position at which the property changes. */
- prop = Fget_text_property (position, propname, WVAR (w, buffer));
+ prop = Fget_text_property (position, propname, WGET (w, buffer));
XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
- end = Fnext_single_property_change (position, propname, WVAR (w, buffer), limit1);
+ end = Fnext_single_property_change (position, propname, WGET (w, buffer), limit1);
if (INTEGERP (end))
endpos = XINT (end);
ptrdiff_t *endptr, ptrdiff_t limit,
int mouse, Lisp_Object overlay)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object prop, position;
ptrdiff_t endpos;
/* Get the `face' or `mouse_face' text property at POS, and
determine the next position at which the property changes. */
- prop = Fget_text_property (position, propname, WVAR (w, buffer));
+ prop = Fget_text_property (position, propname, WGET (w, buffer));
XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
- end = Fnext_single_property_change (position, propname, WVAR (w, buffer), limit1);
+ end = Fnext_single_property_change (position, propname, WGET (w, buffer), limit1);
if (INTEGERP (end))
endpos = XINT (end);
void
xic_set_preeditarea (struct window *w, int x, int y)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
XVaNestedList attr;
XPoint spot;
/* Set up the frame's root window. */
w = XWINDOW (FRAME_ROOT_WINDOW (f));
- WVAR (w, left_col) = WVAR (w, top_line) = make_number (0);
+ WSET (w, left_col, make_number (0));
+ WSET (w, top_line, make_number (0));
if (CONSP (Vx_max_tooltip_size)
&& RANGED_INTEGERP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
&& RANGED_INTEGERP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
{
- WVAR (w, total_cols) = XCAR (Vx_max_tooltip_size);
- WVAR (w, total_lines) = XCDR (Vx_max_tooltip_size);
+ WSET (w, total_cols, XCAR (Vx_max_tooltip_size));
+ WSET (w, total_lines, XCDR (Vx_max_tooltip_size));
}
else
{
- WVAR (w, total_cols) = make_number (80);
- WVAR (w, total_lines) = make_number (40);
+ WSET (w, total_cols, make_number (80));
+ WSET (w, total_lines, make_number (40));
}
- FRAME_TOTAL_COLS (f) = XINT (WVAR (w, total_cols));
+ FRAME_TOTAL_COLS (f) = XINT (WGET (w, total_cols));
adjust_glyphs (f);
w->pseudo_window_p = 1;
/* Display the tooltip text in a temporary buffer. */
old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (WVAR (XWINDOW (FRAME_ROOT_WINDOW (f)), buffer)));
+ set_buffer_internal_1 (XBUFFER (WGET (XWINDOW (FRAME_ROOT_WINDOW (f)), buffer)));
BVAR (current_buffer, truncate_lines) = Qnil;
clear_glyph_matrix (w->desired_matrix);
clear_glyph_matrix (w->current_matrix);
/* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
not in pixels. */
width /= WINDOW_FRAME_COLUMN_WIDTH (w);
- WVAR (w, total_cols) = make_number (width);
+ WSET (w, total_cols, make_number (width));
FRAME_TOTAL_COLS (f) = width;
adjust_glyphs (f);
clear_glyph_matrix (w->desired_matrix);
if (! menubar_widget)
previous_menu_items_used = 0;
- buffer = WVAR (XWINDOW (FRAME_SELECTED_WINDOW (f)), buffer);
+ buffer = WGET (XWINDOW (FRAME_SELECTED_WINDOW (f)), buffer);
specbind (Qinhibit_quit, Qt);
/* Don't let the debugger step into this code
because it is not reentrant. */
/* Detect if a dialog or menu has been posted. MSDOS has its own
implementation on msdos.c. */
-int
+int ATTRIBUTE_CONST
popup_activated (void)
{
return popup_activated_flag;
static void
x_update_window_end (struct window *w, int cursor_on_p, int mouse_face_overwritten_p)
{
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WVAR (w, frame)));
+ Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WGET (w, frame)));
if (!w->pseudo_window_p)
{
overhead is very small. */
if (windows_or_buffers_changed
&& desired_row->full_width_p
- && (f = XFRAME (WVAR (w, frame)),
+ && (f = XFRAME (WGET (w, frame)),
width = FRAME_INTERNAL_BORDER_WIDTH (f),
width != 0)
&& (height = desired_row->visible_height,
static void
x_scroll_run (struct window *w, struct run *run)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
int x, y, width, height, from_y, to_y, bottom_y;
/* Get frame-relative bounding box of the text display area of W,
scroll_bar_end_scroll, 0, 0);
w = XWINDOW (window_being_scrolled);
- if (!NILP (XSCROLL_BAR (WVAR (w, vertical_scroll_bar))->dragging))
+ if (!NILP (XSCROLL_BAR (WGET (w, vertical_scroll_bar))->dragging))
{
- XSCROLL_BAR (WVAR (w, vertical_scroll_bar))->dragging = Qnil;
+ XSCROLL_BAR (WGET (w, vertical_scroll_bar))->dragging = Qnil;
/* The thumb size is incorrect while dragging: fix it. */
set_vertical_scroll_bar (w);
}
XEvent event;
XClientMessageEvent *ev = (XClientMessageEvent *) &event;
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
ptrdiff_t i;
BLOCK_INPUT;
ievent->timestamp = CurrentTime;
#else
ievent->timestamp =
- XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (WVAR (w, frame))));
+ XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (WGET (w, frame))));
#endif
ievent->part = ev->data.l[1];
ievent->code = ev->data.l[2];
static struct scroll_bar *
x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct scroll_bar *bar
= ALLOCATE_PSEUDOVECTOR (struct scroll_bar, x_window, PVEC_OTHER);
Lisp_Object barobj;
#endif
/* Dissociate this scroll bar from its window. */
- WVAR (XWINDOW (bar->window), vertical_scroll_bar) = Qnil;
+ WSET (XWINDOW (bar->window), vertical_scroll_bar, Qnil);
UNBLOCK_INPUT;
}
static void
XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int position)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
+ Lisp_Object barobj;
struct scroll_bar *bar;
int top, height, left, sb_left, width, sb_width;
int window_y, window_height;
#endif
/* Does the scroll bar exist yet? */
- if (NILP (WVAR (w, vertical_scroll_bar)))
+ if (NILP (WGET (w, vertical_scroll_bar)))
{
if (width > 0 && height > 0)
{
/* It may just need to be moved and resized. */
unsigned int mask = 0;
- bar = XSCROLL_BAR (WVAR (w, vertical_scroll_bar));
+ bar = XSCROLL_BAR (WGET (w, vertical_scroll_bar));
BLOCK_INPUT;
}
#endif /* not USE_TOOLKIT_SCROLL_BARS */
- XSETVECTOR (WVAR (w, vertical_scroll_bar), bar);
+ XSETVECTOR (barobj, bar);
+ WSET (w, vertical_scroll_bar, barobj);
}
Lisp_Object barobj;
/* We can't redeem this window's scroll bar if it doesn't have one. */
- if (NILP (WVAR (window, vertical_scroll_bar)))
+ if (NILP (WGET (window, vertical_scroll_bar)))
abort ();
- bar = XSCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XSCROLL_BAR (WGET (window, vertical_scroll_bar));
/* Unlink it from the condemned list. */
f = XFRAME (WINDOW_FRAME (window));
{
/* If the prev pointer is nil, it must be the first in one of
the lists. */
- if (EQ (FRAME_SCROLL_BARS (f), WVAR (window, vertical_scroll_bar)))
+ if (EQ (FRAME_SCROLL_BARS (f), WGET (window, vertical_scroll_bar)))
/* It's not condemned. Everything's fine. */
return;
else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
- WVAR (window, vertical_scroll_bar)))
+ WGET (window, vertical_scroll_bar)))
FSET (f, condemned_scroll_bars, bar->next);
else
/* If its prev pointer is nil, it must be at the front of
static void
x_scroll_bar_note_movement (struct scroll_bar *bar, XEvent *event)
{
- FRAME_PTR f = XFRAME (WVAR (XWINDOW (bar->window), frame));
+ FRAME_PTR f = XFRAME (WGET (XWINDOW (bar->window), frame));
last_mouse_movement_time = event->xmotion.time;
create event iff we don't leave the
selected frame. */
&& (focus_follows_mouse
- || (EQ (WVAR (XWINDOW (window), frame),
- WVAR (XWINDOW (selected_window), frame)))))
+ || (EQ (WGET (XWINDOW (window), frame),
+ WGET (XWINDOW (selected_window), frame)))))
{
inev.ie.kind = SELECT_WINDOW_EVENT;
inev.ie.frame_or_window = window;
static void
x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text_cursor_kinds kind)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (WGET (w, frame));
struct glyph *cursor_glyph;
/* If cursor is out of bounds, don't draw garbage. This can happen
HCoop / bpt / emacs.git / commitdiff