int (* fn) (struct window *, void *),
void *);
static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
-static int window_resize_check (struct window *, int);
-static void window_resize_apply (struct window *, int);
+static int window_resize_check (struct window *, bool);
+static void window_resize_apply (struct window *, bool);
static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
static void select_window_1 (Lisp_Object, bool);
adjust_window_count (w, 1);
}
-/* Build a frequently used 4-integer (X Y W H) list. */
-
-static Lisp_Object
-list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
-{
- return list4 (make_number (x), make_number (y),
- make_number (w), make_number (h));
-}
-
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
doc: /* Return t if OBJECT is a window and nil otherwise. */)
(Lisp_Object object)
DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
doc: /* Return combination limit of window WINDOW.
+WINDOW must be a valid window used in horizontal or vertical combination.
If the return value is nil, child windows of WINDOW can be recombined with
WINDOW's siblings. A return value of t means that child windows of
-WINDOW are never \(re-)combined with WINDOW's siblings.
-
-WINDOW must be a valid window. The return value is meaningful for
-internal windows only. */)
+WINDOW are never \(re-)combined with WINDOW's siblings. */)
(Lisp_Object window)
{
+ struct window *w;
+
CHECK_VALID_WINDOW (window);
+ w = XWINDOW (window);
+ if (!NILP (w->buffer))
+ error ("Combination limit is meaningful for internal windows only");
return XWINDOW (window)->combination_limit;
}
DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
+WINDOW must be a valid window used in horizontal or vertical combination.
If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
siblings. LIMIT t means that child windows of WINDOW are never
\(re-)combined with WINDOW's siblings. Other values are reserved for
-future use.
-
-WINDOW must be a valid window. Setting the combination limit is
-meaningful for internal windows only. */)
+future use. */)
(Lisp_Object window, Lisp_Object limit)
{
- wset_combination_limit (decode_valid_window (window), limit);
+ struct window *w;
+
+ CHECK_VALID_WINDOW (window);
+ w = XWINDOW (window);
+ if (!NILP (w->buffer))
+ error ("Combination limit is meaningful for internal windows only");
+ wset_combination_limit (w, limit);
return limit;
}
integer multiple of the default character height. */)
(Lisp_Object window)
{
- return decode_valid_window (window)->total_lines;
+ return make_number (decode_valid_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 decode_valid_window (window)->total_cols;
+ return make_number (decode_valid_window (window)->total_cols);
}
DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
WINDOW must be a valid window and defaults to the selected one. */)
(Lisp_Object window)
{
- return decode_valid_window (window)->left_col;
+ return make_number (decode_valid_window (window)->left_col);
}
DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
WINDOW must be a valid window and defaults to the selected one. */)
(Lisp_Object window)
{
- return decode_valid_window (window)->top_line;
+ return make_number (decode_valid_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 (w->total_lines);
+ int height = w->total_lines;
if (!MINI_WINDOW_P (w))
{
window_body_cols (struct window *w)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
- int width = XINT (w->total_cols);
+ int width = w->total_cols;
if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
/* Scroll bars occupy a few columns. */
Lisp_Object
window_from_coordinates (struct frame *f, int x, int y,
- enum window_part *part, int tool_bar_p)
+ enum window_part *part, bool tool_bar_p)
{
Lisp_Object window;
struct check_window_data cw;
if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
fset_root_window (XFRAME (o->frame), new);
- if (setflag)
- {
- wset_left_col (n, o->left_col);
- wset_top_line (n, o->top_line);
- wset_total_cols (n, o->total_cols);
- wset_total_lines (n, o->total_lines);
+ if (setflag)
+ {
+ n->left_col = o->left_col;
+ n->top_line = o->top_line;
+ n->total_cols = o->total_cols;
+ n->total_lines = o->total_lines;
wset_normal_cols (n, o->normal_cols);
wset_normal_cols (o, make_float (1.0));
wset_normal_lines (n, o->normal_lines);
{
struct window *w, *p, *c;
Lisp_Object parent, child;
- int horflag;
+ bool horflag;
w = XWINDOW (window);
parent = w->parent;
if (horflag)
wset_normal_cols (c,
- make_float (XFLOATINT (c->total_cols)
- / XFLOATINT (p->total_cols)));
+ make_float ((double) c->total_cols
+ / (double) p->total_cols));
else
wset_normal_lines (c,
- make_float (XFLOATINT (c->total_lines)
- / XFLOATINT (p->total_lines)));
+ make_float ((double) c->total_lines
+ / (double) p->total_lines));
if (NILP (c->next))
{
struct window *w, *r, *s;
struct frame *f;
Lisp_Object sibling, pwindow, swindow IF_LINT (= Qnil), delta;
- ptrdiff_t startpos IF_LINT (= 0);
+ ptrdiff_t startpos IF_LINT (= 0), startbyte IF_LINT (= 0);
int top IF_LINT (= 0), new_top, resize_failed;
w = decode_valid_window (window);
if (!NILP (w->buffer))
{
startpos = marker_position (w->start);
+ startbyte = marker_byte_position (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 (NILP (w->buffer))
{
/* Resize child windows vertically. */
- XSETINT (delta, XINT (r->total_lines)
- - XINT (w->total_lines));
- wset_top_line (w, r->top_line);
+ XSETINT (delta, r->total_lines - w->total_lines);
+ w->top_line = 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)
{
- wset_left_col (w, r->left_col);
- XSETINT (delta,
- XINT (r->total_cols) - XINT (w->total_cols));
- wset_left_col (w, r->left_col);
+ w->left_col = r->left_col;
+ XSETINT (delta, r->total_cols - w->total_cols);
resize_root_window (window, delta, Qt, Qnil);
if (window_resize_check (w, 1))
window_resize_apply (w, 1);
Fset_buffer (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);
+ pos = *vmotion (startpos, startbyte, -top, w);
set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
w->window_end_valid = 0;
reset from the buffer's local settings. */
void
-set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int keep_margins_p)
+set_window_buffer (Lisp_Object window, Lisp_Object buffer,
+ bool run_hooks_p, bool keep_margins_p)
{
struct window *w = XWINDOW (window);
struct buffer *b = XBUFFER (buffer);
WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
horizontal child). */
static void
-make_parent_window (Lisp_Object window, int horflag)
+make_parent_window (Lisp_Object window, bool horflag)
{
Lisp_Object parent;
register struct window *o, *p;
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. */
- wset_left_col (w, make_number (0));
- wset_top_line (w, make_number (0));
- wset_total_lines (w, make_number (0));
- wset_total_cols (w, make_number (0));
wset_normal_lines (w, make_float (1.0));
wset_normal_cols (w, make_float (1.0));
wset_new_total (w, make_number (0));
`window-min-height' or `window-min-width'. It does check that window
sizes do not drop below one line (two columns). */
static int
-window_resize_check (struct window *w, int horflag)
+window_resize_check (struct window *w, bool horflag)
{
struct window *c;
This function does not perform any error checks. Make sure you have
run window_resize_check on W before applying this function. */
static void
-window_resize_apply (struct window *w, int horflag)
+window_resize_apply (struct window *w, bool horflag)
{
struct window *c;
int pos;
parent window has been set *before*. */
if (horflag)
{
- wset_total_cols (w, w->new_total);
+ w->total_cols = XFASTINT (w->new_total);
if (NUMBERP (w->new_normal))
wset_normal_cols (w, w->new_normal);
- pos = XINT (w->left_col);
+ pos = w->left_col;
}
else
{
- wset_total_lines (w, w->new_total);
+ w->total_lines = XFASTINT (w->new_total);
if (NUMBERP (w->new_normal))
wset_normal_lines (w, w->new_normal);
- pos = XINT (w->top_line);
+ pos = w->top_line;
}
if (!NILP (w->vchild))
while (c)
{
if (horflag)
- wset_left_col (c, make_number (pos));
+ c->left_col = pos;
else
- wset_top_line (c, make_number (pos));
+ c->top_line = pos;
window_resize_apply (c, horflag);
if (!horflag)
- pos = pos + XINT (c->total_lines);
+ pos = pos + c->total_lines;
c = NILP (c->next) ? 0 : XWINDOW (c->next);
}
}
while (c)
{
if (horflag)
- wset_left_col (c, make_number (pos));
+ c->left_col = pos;
else
- wset_top_line (c, make_number (pos));
+ c->top_line = pos;
window_resize_apply (c, horflag);
if (horflag)
- pos = pos + XINT (c->total_cols);
+ pos = pos + c->total_cols;
c = NILP (c->next) ? 0 : XWINDOW (c->next);
}
}
{
struct frame *f = decode_live_frame (frame);
struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
- int horflag = !NILP (horizontal);
+ bool horflag = !NILP (horizontal);
if (!window_resize_check (r, horflag)
- || ! EQ (r->new_total,
- (horflag ? r->total_cols : r->total_lines)))
+ || (XINT (r->new_total)
+ != (horflag ? r->total_cols : r->total_lines)))
return Qnil;
block_input ();
satisfy the request. The result will be meaningful if and only if
F's windows have meaningful sizes when you call this. */
void
-resize_frame_windows (struct frame *f, int size, int horflag)
+resize_frame_windows (struct frame *f, int size, bool horflag)
{
Lisp_Object root = f->root_window;
struct window *r = XWINDOW (root);
- ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
? 1 : 0)));
- wset_top_line (r, make_number (FRAME_TOP_MARGIN (f)));
+ r->top_line = FRAME_TOP_MARGIN (f);
if (NILP (r->vchild) && NILP (r->hchild))
/* For a leaf root window just set the size. */
if (horflag)
- wset_total_cols (r, make_number (new_size));
+ r->total_cols = new_size;
else
- wset_total_lines (r, make_number (new_size));
+ r->total_lines = new_size;
else
{
/* old_size is the old size of the frame's root window. */
- int old_size = XFASTINT (horflag ? r->total_cols
- : r->total_lines);
+ int old_size = horflag ? r->total_cols : r->total_lines;
Lisp_Object delta;
XSETINT (delta, new_size - old_size);
root = f->selected_window;
Fdelete_other_windows_internal (root, Qnil);
if (horflag)
- wset_total_cols (XWINDOW (root), make_number (new_size));
+ XWINDOW (root)->total_cols = new_size;
else
- wset_total_lines (XWINDOW (root), make_number (new_size));
+ XWINDOW (root)->total_lines = new_size;
}
}
}
{
m = XWINDOW (mini);
if (horflag)
- wset_total_cols (m, make_number (size));
+ m->total_cols = size;
else
{
/* Are we sure we always want 1 line here? */
- wset_total_lines (m, make_number (1));
- wset_top_line
- (m, make_number (XINT (r->top_line) + XINT (r->total_lines)));
+ m->total_lines = 1;
+ m->top_line = r->top_line + r->total_lines;
}
}
register Lisp_Object new, frame, reference;
register struct window *o, *p, *n, *r;
struct frame *f;
- int horflag
+ bool horflag
/* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
= EQ (side, Qt) || EQ (side, Qleft) || EQ (side, Qright);
int combination_limit = 0;
p = XWINDOW (o->parent);
/* Temporarily pretend we split the parent window. */
wset_new_total
- (p, make_number (XINT (horflag ? p->total_cols : p->total_lines)
+ (p, make_number ((horflag ? p->total_cols : p->total_lines)
- XINT (total_size)));
if (!window_resize_check (p, horflag))
error ("Window sizes don't fit");
else
/* Undo the temporary pretension. */
- wset_new_total (p, horflag ? p->total_cols : p->total_lines);
+ wset_new_total (p, make_number
+ (horflag ? p->total_cols : p->total_lines));
}
else
{
if (!window_resize_check (o, horflag))
error ("Resizing old window failed");
else if (XINT (total_size) + XINT (o->new_total)
- != XINT (horflag ? o->total_cols : o->total_lines))
+ != (horflag ? o->total_cols : o->total_lines))
error ("Sum of sizes of old and new window don't fit");
}
that its children get merged into another window. */
wset_combination_limit (p, Qt);
/* These get applied below. */
- wset_new_total (p, horflag ? o->total_cols : o->total_lines);
+ wset_new_total (p, make_number
+ (horflag ? o->total_cols : o->total_lines));
wset_new_normal (p, new_normal);
}
else
/* Directly assign orthogonal coordinates and sizes. */
if (horflag)
{
- wset_top_line (n, o->top_line);
- wset_total_lines (n, o->total_lines);
+ n->top_line = o->top_line;
+ n->total_lines = o->total_lines;
}
else
{
- wset_left_col (n, o->left_col);
- wset_total_cols (n, o->total_cols);
+ n->left_col = o->left_col;
+ n->total_cols = o->total_cols;
}
/* Iso-coordinates and sizes are assigned by window_resize_apply,
register Lisp_Object parent, sibling, frame, root;
struct window *w, *p, *s, *r;
struct frame *f;
- int horflag;
+ bool horflag;
int before_sibling = 0;
w = decode_any_window (window);
}
if (window_resize_check (r, horflag)
- && EQ (r->new_total,
- (horflag ? r->total_cols : r->total_lines)))
+ && (XINT (r->new_total)
+ == (horflag ? r->total_cols : r->total_lines)))
/* We can delete WINDOW now. */
{
window_resize_apply (r, 0);
/* Grow the mini-window. */
- wset_top_line
- (w, make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
- wset_total_lines
- (w, make_number (XFASTINT (w->total_lines) - XINT (value)));
+ w->top_line = r->top_line + r->total_lines;
+ w->total_lines -= XINT (value);
w->last_modified = 0;
w->last_overlay_modified = 0;
eassert (MINI_WINDOW_P (w));
- size = XINT (w->total_lines);
+ size = w->total_lines;
if (size > 1)
{
root = FRAME_ROOT_WINDOW (f);
window_resize_apply (r, 0);
/* Shrink the mini-window. */
- wset_top_line (w, make_number (XFASTINT (r->top_line)
- + XFASTINT (r->total_lines)));
- wset_total_lines (w, make_number (1));
+ w->top_line = r->top_line + r->total_lines;
+ w->total_lines = 1;
w->last_modified = 0;
w->last_overlay_modified = 0;
error ("Cannot resize a minibuffer-only frame");
r = XWINDOW (FRAME_ROOT_WINDOW (f));
- height = XINT (r->total_lines) + XINT (w->total_lines);
+ height = r->total_lines + w->total_lines;
if (window_resize_check (r, 0)
&& XINT (w->new_total) > 0
&& height == XINT (r->new_total) + XINT (w->new_total))
block_input ();
window_resize_apply (r, 0);
- wset_total_lines (w, w->new_total);
- wset_top_line (w, make_number (XINT (r->top_line)
- + XINT (r->total_lines)));
+ w->total_lines = XFASTINT (w->new_total);
+ w->top_line = r->top_line + r->total_lines;
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
int
window_internal_height (struct window *w)
{
- int ht = XFASTINT (w->total_lines);
+ int ht = w->total_lines;
if (!MINI_WINDOW_P (w))
{
even if there is a header line. */
this_scroll_margin = max (0, scroll_margin);
this_scroll_margin
- = min (this_scroll_margin, XFASTINT (w->total_lines) / 4);
+ = min (this_scroll_margin, w->total_lines / 4);
this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
if (n > 0)
register Lisp_Object tem;
int lose;
Lisp_Object bolp;
- ptrdiff_t startpos;
+ ptrdiff_t startpos = marker_position (w->start);
+ ptrdiff_t startbyte = marker_byte_position (w->start);
Lisp_Object original_pos = Qnil;
/* If scrolling screen-fulls, compute the number of lines to
if (whole)
n *= max (1, ht - next_screen_context_lines);
- startpos = marker_position (w->start);
-
if (!NILP (Vscroll_preserve_screen_position))
{
if (window_scroll_preserve_vpos <= 0
|| NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
{
struct position posit
- = *compute_motion (startpos, 0, 0, 0,
- PT, ht, 0,
- -1, w->hscroll,
- 0, w);
+ = *compute_motion (startpos, startbyte, 0, 0, 0,
+ PT, ht, 0, -1, w->hscroll, 0, w);
window_scroll_preserve_vpos = posit.vpos;
window_scroll_preserve_hpos = posit.hpos + w->hscroll;
}
{
Fvertical_motion (make_number (- (ht / 2)), window);
startpos = PT;
+ startbyte = PT_BYTE;
}
- SET_PT (startpos);
+ SET_PT_BOTH (startpos, startbyte);
lose = n < 0 && PT == BEGV;
Fvertical_motion (make_number (n), window);
pos = PT;
{
/* Don't use a scroll margin that is negative or too large. */
int this_scroll_margin =
- max (0, min (scroll_margin, XINT (w->total_lines) / 4));
+ max (0, min (scroll_margin, w->total_lines / 4));
set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
w->start_at_line_beg = !NILP (bolp);
++windows_or_buffers_changed;
Fset_buffer (w->buffer);
- SET_PT (marker_position (w->pointm));
+ SET_PT_BOTH (marker_position (w->pointm), marker_byte_position (w->pointm));
if (NILP (arg))
window_scroll (window, 1, 1, 1);
DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
doc: /* Center point in selected window and maybe redisplay frame.
-With prefix argument ARG, recenter putting point on screen line ARG
+With a numeric prefix argument ARG, recenter putting point on screen line ARG
relative to the selected window. If ARG is negative, it counts up from the
bottom of the window. (ARG should be less than the height of the window.)
/* Do this after making BUF current
in case scroll_margin is buffer-local. */
this_scroll_margin =
- max (0, min (scroll_margin, XFASTINT (w->total_lines) / 4));
+ max (0, min (scroll_margin, 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
iarg = max (iarg, this_scroll_margin);
- pos = *vmotion (PT, -iarg, w);
+ pos = *vmotion (PT, PT_BYTE, -iarg, w);
charpos = pos.bufpos;
bytepos = pos.bytepos;
}
iarg = clip_to_bounds (this_scroll_margin, iarg,
ht - this_scroll_margin - 1);
- pos = *vmotion (PT, - iarg, w);
+ pos = *vmotion (PT, PT_BYTE, - iarg, w);
charpos = pos.bufpos;
bytepos = pos.bytepos;
}
wset_prev (w, Qnil);
if (!NILP (w->parent))
{
- if (EQ (p->total_cols, XWINDOW (w->parent)->total_cols))
+ if (XINT (p->total_cols) == XWINDOW (w->parent)->total_cols)
{
wset_vchild (XWINDOW (w->parent), p->window);
wset_hchild (XWINDOW (w->parent), Qnil);
}
}
- /* If we squirreled away the buffer in the window's height,
- restore it now. */
- if (BUFFERP (w->total_lines))
- wset_buffer (w, w->total_lines);
- wset_left_col (w, p->left_col);
- wset_top_line (w, p->top_line);
- wset_total_cols (w, p->total_cols);
- wset_total_lines (w, p->total_lines);
+ /* If we squirreled away the buffer, restore it now. */
+ if (BUFFERP (w->combination_limit))
+ wset_buffer (w, w->combination_limit);
+ w->left_col = XFASTINT (p->left_col);
+ w->top_line = XFASTINT (p->top_line);
+ w->total_cols = XFASTINT (p->total_cols);
+ w->total_lines = XFASTINT (p->total_lines);
wset_normal_cols (w, p->normal_cols);
wset_normal_lines (w, p->normal_lines);
w->hscroll = XFASTINT (p->hscroll);
/* Delete WINDOW's siblings (we traverse postorderly). */
delete_all_child_windows (w->next);
- /* See Fset_window_configuration for excuse. */
- wset_total_lines (w, w->buffer);
-
if (!NILP (w->vchild))
{
delete_all_child_windows (w->vchild);
unshow_buffer (w);
unchain_marker (XMARKER (w->pointm));
unchain_marker (XMARKER (w->start));
+ /* Since combination limit makes sense for an internal windows
+ only, we use this slot to save the buffer for the sake of
+ possible resurrection in Fset_window_configuration. */
+ wset_combination_limit (w, w->buffer);
wset_buffer (w, Qnil);
}
wset_temslot (w, make_number (i)); i++;
p->window = window;
p->buffer = w->buffer;
- p->left_col = w->left_col;
- p->top_line = w->top_line;
- p->total_cols = w->total_cols;
- p->total_lines = w->total_lines;
+ p->left_col = make_number (w->left_col);
+ p->top_line = make_number (w->top_line);
+ p->total_cols = make_number (w->total_cols);
+ p->total_lines = make_number (w->total_lines);
p->normal_cols = w->normal_cols;
p->normal_lines = w->normal_lines;
XSETFASTINT (p->hscroll, w->hscroll);
means freeze the window start. */
void
-freeze_window_starts (struct frame *f, int freeze_p)
+freeze_window_starts (struct frame *f, bool freeze_p)
{
foreach_window (f, freeze_window_start, (void *) (freeze_p ? f : 0));
}