/* Window creation, deletion and examination for GNU Emacs.
Does not include redisplay.
- Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
- 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ Copyright (C) 1985-1987, 1993-1998, 2000-2011
Free Software Foundation, Inc.
This file is part of GNU Emacs.
Lisp_Object, int);
static void decode_next_window_args (Lisp_Object *, Lisp_Object *,
Lisp_Object *);
+static void foreach_window (struct frame *,
+ int (* fn) (struct window *, void *),
+ void *);
static int foreach_window_1 (struct window *,
int (* fn) (struct window *, void *),
void *);
static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
+static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
/* This is the window in which the terminal's cursor should
be left when nothing is being done with it. This must
Lisp_Object minibuf_selected_window;
-/* Non-nil means it is the window for C-M-v to scroll
- when the mini-buffer is selected. */
-
-Lisp_Object Vminibuf_scroll_window;
-
-/* Non-nil means this is the buffer whose window C-M-v should scroll. */
-
-Lisp_Object Vother_window_scroll_buffer;
-
-/* Non-nil means it's function to call to display temp buffers. */
-
-Lisp_Object Vtemp_buffer_show_function;
-
-/* Non-zero means line and page scrolling on tall lines (with images)
- does partial scrolling by modifying window-vscroll. */
-
-int auto_window_vscroll_p;
-
-/* Non-zero means to use mode-line-inactive face in all windows but the
- selected-window and the minibuffer-scroll-window when the
- minibuffer is active. */
-int mode_line_in_non_selected_windows;
-
-/* If a window gets smaller than either of these, it is removed. */
-
-EMACS_INT window_min_height;
-EMACS_INT window_min_width;
-
/* Hook run at end of temp_output_buffer_show. */
Lisp_Object Qtemp_buffer_show_hook;
-/* Number of lines of continuity in scrolling by screenfuls. */
-
-EMACS_INT next_screen_context_lines;
-
/* Incremented for each window created. */
static int sequence_number;
/* Hook to run when window config changes. */
static Lisp_Object Qwindow_configuration_change_hook;
-static Lisp_Object Vwindow_configuration_change_hook;
-
-/* Non-nil means scroll commands try to put point
- at the same screen height as previously. */
-
-Lisp_Object Vscroll_preserve_screen_position;
-
-/* Non-nil means that text is inserted before window's markers. */
-
-Lisp_Object Vwindow_point_insertion_type;
-
/* Incremented by 1 whenever a window is deleted. */
int window_deletion_count;
#if 0 /* This isn't used anywhere. */
/* Nonzero means we can split a frame even if it is "unsplittable". */
static int inhibit_frame_unsplittable;
-#endif /* 0 */
-
-/* If non-nil, then the `recenter' command with a nil argument
- the entire frame to be redrawn; the special value `tty' causes the
- frame to be redrawn only if it is a tty frame. */
-
-static Lisp_Object Vrecenter_redisplay;
+#endif
\f
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
return val;
}
-DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
+DEFUE ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
doc: /* Return the window that the cursor now appears in and commands apply to. */)
(void)
{
return FRAME_MINIBUF_WINDOW (XFRAME (frame));
}
-DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1, 0,
+DEFUE ("window-minibuffer-p", Fwindow_minibuffer_p,
+ Swindow_minibuffer_p, 0, 1, 0,
doc: /* Return non-nil if WINDOW is a minibuffer window.
WINDOW defaults to the selected window. */)
(Lisp_Object window)
}
-DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
+DEFUE ("pos-visible-in-window-p", Fpos_visible_in_window_p,
Spos_visible_in_window_p, 0, 3, 0,
doc: /* Return non-nil if position POS is currently on the frame in WINDOW.
Return nil if that position is scrolled vertically out of view.
return XWINDOW (window);
}
-DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
+DEFUE ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
doc: /* Return the buffer that WINDOW is displaying.
WINDOW defaults to the selected window. */)
(Lisp_Object window)
return value;
}
-DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
+DEFUE ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
Return POS. */)
(Lisp_Object window, Lisp_Object pos)
}
-DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
+DEFUE ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
0, 1, 0,
doc: /* Return non-nil when WINDOW is dedicated to its buffer.
More precisely, return the value assigned by the last call of
{
struct buffer *b = XBUFFER (w->buffer);
- if (DISP_TABLE_P (b->display_table))
- dp = XCHAR_TABLE (b->display_table);
+ if (DISP_TABLE_P (BVAR (b, display_table)))
+ dp = XCHAR_TABLE (BVAR (b, display_table));
else if (DISP_TABLE_P (Vstandard_display_table))
dp = XCHAR_TABLE (Vstandard_display_table);
}
return table;
}
\f
+static void delete_window (Lisp_Object);
+
/* Record info on buffer window w is displaying
when it is about to cease to display that buffer. */
static void
So don't clobber point in that buffer. */
if (! EQ (buf, XWINDOW (selected_window)->buffer)
/* This line helps to fix Horsley's testbug.el bug. */
- && !(WINDOWP (b->last_selected_window)
- && w != XWINDOW (b->last_selected_window)
- && EQ (buf, XWINDOW (b->last_selected_window)->buffer)))
+ && !(WINDOWP (BVAR (b, last_selected_window))
+ && w != XWINDOW (BVAR (b, last_selected_window))
+ && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->buffer)))
temp_set_point_both (b,
clip_to_bounds (BUF_BEGV (b),
XMARKER (w->pointm)->charpos,
marker_byte_position (w->pointm),
BUF_ZV_BYTE (b)));
- if (WINDOWP (b->last_selected_window)
- && w == XWINDOW (b->last_selected_window))
- b->last_selected_window = Qnil;
+ if (WINDOWP (BVAR (b, last_selected_window))
+ && w == XWINDOW (BVAR (b, last_selected_window)))
+ BVAR (b, last_selected_window) = Qnil;
}
/* Put replacement into the window structure in place of old. */
children be children of that parent instead. ***/
}
-DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "",
+DEFUE ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "",
doc: /* Remove WINDOW from its frame.
WINDOW defaults to the selected window. Return nil.
Signal an error when WINDOW is the only window on its frame. */)
return Qnil;
}
-void
+static void
delete_window (register Lisp_Object window)
{
register Lisp_Object tem, parent, sib;
ALL_FRAMES t means search all frames,
nil means search just current frame,
- `visible' means search just visible frames,
- 0 means search visible and iconified frames,
+ `visible' means search just visible frames on the
+ current terminal,
+ 0 means search visible and iconified frames on the
+ current terminal,
a window means search the frame that window belongs to,
a frame means consider windows on that frame, only. */
/* Decode arguments as allowed by Fnext_window, Fprevious_window, and
- Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
- ALL_FRAMES. */
+ Fwindow_list. See candidate_window_p for the meaning of WINDOW,
+ MINIBUF, and ALL_FRAMES. */
static void
decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object *all_frames)
;
else if (!EQ (*all_frames, Qt))
*all_frames = Qnil;
-
- /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
- search just current frame, `visible' meaning search just visible
- frames, 0 meaning search visible and iconified frames, or a
- window, meaning search the frame that window belongs to, or a
- frame, meaning consider windows on that frame, only. */
}
}
-DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
+DEFUE ("next-window", Fnext_window, Snext_window, 0, 3, 0,
doc: /* Return window following WINDOW in cyclic ordering of windows.
WINDOW defaults to the selected window. The optional arguments
MINIBUF and ALL-FRAMES specify the set of windows to consider.
windows on all frames that share that minibuffer too.
ALL-FRAMES t means consider all windows on all existing frames.
ALL-FRAMES `visible' means consider all windows on all visible
- frames.
+ frames on the current terminal.
ALL-FRAMES 0 means consider all windows on all visible and
- iconified frames.
+ iconified frames on the current terminal.
ALL-FRAMES a frame means consider all windows on that frame only.
Anything else means consider all windows on WINDOW's frame and no
others.
case DELETE_BUFFER_WINDOWS:
if (EQ (w->buffer, obj))
{
- struct frame *f = XFRAME (WINDOW_FRAME (w));
+ struct frame *fr = XFRAME (WINDOW_FRAME (w));
/* If this window is dedicated, and in a frame of its own,
kill the frame. */
- if (EQ (window, FRAME_ROOT_WINDOW (f))
+ if (EQ (window, FRAME_ROOT_WINDOW (fr))
&& !NILP (w->dedicated)
- && other_visible_frames (f))
+ && other_visible_frames (fr))
{
/* Skip the other windows on this frame.
There might be one, the minibuffer! */
if (EQ (w->buffer, obj))
{
Lisp_Object buffer;
- struct frame *f = XFRAME (w->frame);
+ struct frame *fr = XFRAME (w->frame);
/* Find another buffer to show in this window. */
buffer = Fother_buffer (obj, Qnil, w->frame);
/* If this window is dedicated, and in a frame of its own,
kill the frame. */
- if (EQ (window, FRAME_ROOT_WINDOW (f))
+ if (EQ (window, FRAME_ROOT_WINDOW (fr))
&& !NILP (w->dedicated)
- && other_visible_frames (f))
+ && other_visible_frames (fr))
{
/* Skip the other windows on this frame.
There might be one, the minibuffer! */
}
else if (!NILP (w->dedicated) && !NILP (w->parent))
{
- Lisp_Object window;
- XSETWINDOW (window, w);
+ Lisp_Object window_to_delete;
+ XSETWINDOW (window_to_delete, w);
/* If this window is dedicated and not the only window
in its frame, then kill it. */
- Fdelete_window (window);
+ Fdelete_window (window_to_delete);
}
else
{
/* Check for a window that has a killed buffer. */
case CHECK_ALL_WINDOWS:
if (! NILP (w->buffer)
- && NILP (XBUFFER (w->buffer)->name))
+ && NILP (BVAR (XBUFFER (w->buffer), name)))
abort ();
break;
frame);
}
-DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 0, 2, 0,
+DEFUE ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 0, 2, 0,
doc: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
BUFFER-OR-NAME may be a buffer or a buffer name and defaults to the
current buffer.
{
int safe_size = (MIN_SAFE_WINDOW_HEIGHT
+ ((BUFFERP (w->buffer)
- && !NILP (XBUFFER (w->buffer)->mode_line_format))
+ && !NILP (BVAR (XBUFFER (w->buffer), mode_line_format)))
? 1 : 0));
return safe_p ? safe_size : max (window_min_height, safe_size);
while (total_shrink > total_removed)
{
int nonzero_sizes = 0;
- int nonzero_idx = -1;
for (i = 0; i < nchildren; ++i)
if (new_sizes[i] > 0)
- {
- ++nonzero_sizes;
- nonzero_idx = i;
- }
+ ++nonzero_sizes;
for (i = 0; i < nchildren; ++i)
if (new_sizes[i] > min_sizes[i])
}
else if (!NILP (*forward))
{
- int fixed_size, each, extra, n;
+ int fixed_size, each IF_LINT (= 0), extra IF_LINT (= 0), n;
int resize_fixed_p, nfixed;
int last_pos, first_pos, nchildren, total;
int *new_sizes = NULL;
last_pos = first_pos;
for (n = 0, child = *forward; !NILP (child); child = c->next, ++n)
{
- int new_size, old_size;
+ int new_child_size, old_child_size;
c = XWINDOW (child);
- old_size = WINDOW_TOTAL_SIZE (c, width_p);
- new_size = old_size;
+ old_child_size = WINDOW_TOTAL_SIZE (c, width_p);
+ new_child_size = old_child_size;
/* The top or left edge position of this child equals the
bottom or right edge of its predecessor. */
/* If this child can be resized, do it. */
if (resize_fixed_p || !window_fixed_size_p (c, width_p, 0))
{
- new_size = new_sizes ? new_sizes[n] : old_size + each + extra;
+ new_child_size =
+ new_sizes ? new_sizes[n] : old_child_size + each + extra;
extra = 0;
}
/* Set new size. Note that size_window also propagates
edge positions to children, so it's not a no-op if we
didn't change the child's size. */
- size_window (child, new_size, width_p, 1, first_only, last_only);
+ size_window (child, new_child_size, width_p, 1,
+ first_only, last_only);
/* Remember the bottom/right edge position of this child; it
will be used to set the top/left edge of the next child. */
- last_pos += new_size;
+ last_pos += new_child_size;
}
xfree (new_sizes);
\f
int window_select_count;
-EXFUN (Fset_window_fringes, 4);
-EXFUN (Fset_window_scroll_bars, 4);
+INFUN (Fset_window_margins, 3);
+INFUN (Fset_window_fringes, 4);
+INFUN (Fset_window_scroll_bars, 4);
+INFUN (Fset_window_vscroll, 3);
static void
run_funs (Lisp_Object funs)
if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook,
buffer)))
{
- int count = SPECPDL_INDEX ();
+ int count1 = SPECPDL_INDEX ();
record_unwind_protect (select_window_norecord, Fselected_window ());
select_window_norecord (window);
run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook,
buffer));
- unbind_to (count, Qnil);
+ unbind_to (count1, Qnil);
}
}
}
w->buffer = buffer;
if (EQ (window, selected_window))
- b->last_selected_window = window;
+ BVAR (b, last_selected_window) = window;
/* Let redisplay errors through. */
b->display_error_modiff = 0;
/* Update time stamps of buffer display. */
- if (INTEGERP (b->display_count))
- XSETINT (b->display_count, XINT (b->display_count) + 1);
- b->display_time = Fcurrent_time ();
+ if (INTEGERP (BVAR (b, display_count)))
+ XSETINT (BVAR (b, display_count), XINT (BVAR (b, display_count)) + 1);
+ BVAR (b, display_time) = Fcurrent_time ();
XSETFASTINT (w->window_end_pos, 0);
XSETFASTINT (w->window_end_vpos, 0);
w->left_margin_cols = w->right_margin_cols = Qnil;
Fset_window_fringes (window,
- b->left_fringe_width, b->right_fringe_width,
- b->fringes_outside_margins);
+ BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
+ BVAR (b, fringes_outside_margins));
Fset_window_scroll_bars (window,
- b->scroll_bar_width,
- b->vertical_scroll_bar_type, Qnil);
+ BVAR (b, scroll_bar_width),
+ BVAR (b, vertical_scroll_bar_type), Qnil);
w->left_margin_cols = save_left;
w->right_margin_cols = save_right;
Fset_window_margins (window,
- b->left_margin_cols, b->right_margin_cols);
+ BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
}
if (run_hooks_p)
}
-DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
+DEFUE ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.
WINDOW defaults to the selected window. BUFFER-OR-NAME must be a buffer
or the name of an existing buffer. Optional third argument KEEP-MARGINS
XSETWINDOW (window, w);
buffer = Fget_buffer (buffer_or_name);
CHECK_BUFFER (buffer);
- if (NILP (XBUFFER (buffer)->name))
+ if (NILP (BVAR (XBUFFER (buffer), name)))
error ("Attempt to display deleted buffer");
tem = w->buffer;
else if (!EQ (tem, Qt))
/* w->buffer is t when the window is first being set up. */
{
- if (!EQ (tem, buffer))
- if (EQ (w->dedicated, Qt))
- error ("Window is dedicated to `%s'", SDATA (XBUFFER (tem)->name));
- else
- w->dedicated = Qnil;
+ if (EQ (tem, buffer))
+ return Qnil;
+ else if (EQ (w->dedicated, Qt))
+ error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
+ else
+ w->dedicated = Qnil;
unshow_buffer (w);
}
return Qnil;
}
-/* Note that selected_window can be nil when this is called from
- Fset_window_configuration. */
-
-DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
- doc: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
-If WINDOW is not already selected, make WINDOW's buffer current
-and make WINDOW the frame's selected window. Return WINDOW.
-Optional second arg NORECORD non-nil means do not put this buffer
-at the front of the list of recently selected ones and do not
-make this window the most recently selected one.
+/* If select_window is called with inhibit_point_swap non-zero it will
+ not store point of the old selected window's buffer back into that
+ window's pointm slot. This is needed by Fset_window_configuration to
+ avoid that the display routine is called with selected_window set to
+ Qnil causing a subsequent crash. */
-Note that the main editor command loop selects the buffer of the
-selected window before each command. */)
- (register Lisp_Object window, Lisp_Object norecord)
+static Lisp_Object
+select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
{
register struct window *w;
register struct window *ow;
record_buffer (w->buffer);
}
- if (EQ (window, selected_window))
+ if (EQ (window, selected_window) && !inhibit_point_swap)
return window;
sf = SELECTED_FRAME ();
/* Store the current buffer's actual point into the
old selected window. It belongs to that window,
and when the window is not selected, must be in the window. */
- if (!NILP (selected_window))
+ if (!inhibit_point_swap)
{
ow = XWINDOW (selected_window);
if (! NILP (ow->buffer))
Fset_buffer (w->buffer);
- XBUFFER (w->buffer)->last_selected_window = window;
+ BVAR (XBUFFER (w->buffer), last_selected_window) = window;
/* Go to the point recorded in the window.
This is important when the buffer is in more
return window;
}
+
+/* Note that selected_window can be nil when this is called from
+ Fset_window_configuration. */
+
+DEFUE ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
+ doc: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
+If WINDOW is not already selected, make WINDOW's buffer current
+and make WINDOW the frame's selected window. Return WINDOW.
+Optional second arg NORECORD non-nil means do not put this buffer
+at the front of the list of recently selected ones and do not
+make this window the most recently selected one.
+
+Note that the main editor command loop selects the buffer of the
+selected window before each command. */)
+ (register Lisp_Object window, Lisp_Object norecord)
+{
+ return select_window (window, norecord, 0);
+}
+
static Lisp_Object
select_window_norecord (Lisp_Object window)
{
? Fselect_frame (frame, Qt) : selected_frame;
}
\f
-Lisp_Object
+static Lisp_Object
display_buffer (Lisp_Object buffer, Lisp_Object not_this_window_p, Lisp_Object override_frame)
{
return call3 (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
if (STRINGP (object))
object = Fget_buffer (object);
- if (BUFFERP (object) && !NILP (XBUFFER (object)->name))
+ if (BUFFERP (object) && !NILP (BVAR (XBUFFER (object), name)))
{
/* Walk all windows looking for buffer, and force update
of each of those windows. */
register Lisp_Object window;
register struct window *w;
- XBUFFER (buf)->directory = current_buffer->directory;
+ BVAR (XBUFFER (buf), directory) = BVAR (current_buffer, directory);
Fset_buffer (buf);
BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
BEGV = BEG;
ZV = Z;
SET_PT (BEG);
-#if 0 /* rms: there should be no reason for this. */
- XBUFFER (buf)->prevent_redisplay_optimizations_p = 1;
-#endif
set_buffer_internal (old);
if (!NILP (Vtemp_buffer_show_function))
/* Run temp-buffer-show-hook, with the chosen window selected
and its buffer current. */
-
- if (!NILP (Vrun_hooks)
- && !NILP (Fboundp (Qtemp_buffer_show_hook))
- && !NILP (Fsymbol_value (Qtemp_buffer_show_hook)))
- {
- int count = SPECPDL_INDEX ();
- Lisp_Object prev_window, prev_buffer;
- prev_window = selected_window;
- XSETBUFFER (prev_buffer, old);
-
- /* Select the window that was chosen, for running the hook.
- Note: Both Fselect_window and select_window_norecord may
- set-buffer to the buffer displayed in the window,
- so we need to save the current buffer. --stef */
- record_unwind_protect (Fset_buffer, prev_buffer);
- record_unwind_protect (select_window_norecord, prev_window);
- Fselect_window (window, Qt);
- Fset_buffer (w->buffer);
- call1 (Vrun_hooks, Qtemp_buffer_show_hook);
- unbind_to (count, Qnil);
- }
+ {
+ int count = SPECPDL_INDEX ();
+ Lisp_Object prev_window, prev_buffer;
+ prev_window = selected_window;
+ XSETBUFFER (prev_buffer, old);
+
+ /* Select the window that was chosen, for running the hook.
+ Note: Both Fselect_window and select_window_norecord may
+ set-buffer to the buffer displayed in the window,
+ so we need to save the current buffer. --stef */
+ record_unwind_protect (Fset_buffer, prev_buffer);
+ record_unwind_protect (select_window_norecord, prev_window);
+ Fselect_window (window, Qt);
+ Fset_buffer (w->buffer);
+ Frun_hooks (1, &Qtemp_buffer_show_hook);
+ unbind_to (count, Qnil);
+ }
}
}
+
+DEFUN ("internal-temp-output-buffer-show",
+ Ftemp_output_buffer_show, Stemp_output_buffer_show,
+ 1, 1, 0,
+ doc: /* Internal function for `with-output-to-temp-buffer''. */)
+ (Lisp_Object buf)
+{
+ temp_output_buffer_show (buf);
+ return Qnil;
+}
\f
static void
make_dummy_parent (Lisp_Object window)
error ("Window height %d too small (after splitting)", size_int);
if (size_int + window_safe_height > XFASTINT (o->total_lines))
error ("Window height %d too small (after splitting)",
- XFASTINT (o->total_lines) - size_int);
+ (int) (XFASTINT (o->total_lines) - size_int));
if (NILP (o->parent)
|| NILP (XWINDOW (o->parent)->vchild))
{
error ("Window width %d too small (after splitting)", size_int);
if (size_int + window_safe_width > XFASTINT (o->total_cols))
error ("Window width %d too small (after splitting)",
- XFASTINT (o->total_cols) - size_int);
+ (int) (XFASTINT (o->total_cols) - size_int));
if (NILP (o->parent)
|| NILP (XWINDOW (o->parent)->hchild))
{
return Qnil;
}
-int
+static int
window_height (Lisp_Object window)
{
register struct window *p = XWINDOW (window);
return WINDOW_TOTAL_LINES (p);
}
-int
+static int
window_width (Lisp_Object window)
{
register struct window *p = XWINDOW (window);
{
/* If trying to grow this window to or beyond size of the parent,
just delete all the sibling windows. */
- Lisp_Object start, tem, next;
+ Lisp_Object start, tem;
start = XWINDOW (parent)->vchild;
if (NILP (start))
tem = XWINDOW (window)->next;
while (! NILP (tem))
{
- next = XWINDOW (tem)->next;
+ Lisp_Object next1 = XWINDOW (tem)->next;
delete_window (tem);
- tem = next;
+ tem = next1;
}
/* Delete any siblings that come after WINDOW.
tem = start;
while (! EQ (tem, window))
{
- next = XWINDOW (tem)->next;
+ Lisp_Object next1 = XWINDOW (tem)->next;
delete_window (tem);
- tem = next;
+ tem = next1;
}
}
else
possibility of point becoming "stuck" on a tall line when
scrolling by one line. */
if (window_scroll_pixel_based_preserve_y < 0
- || !SYMBOLP (current_kboard->Vlast_command)
- || NILP (Fget (current_kboard->Vlast_command, Qscroll_command)))
+ || !SYMBOLP (KVAR (current_kboard, Vlast_command))
+ || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
{
start_display (&it, w, start);
move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
looking at an image that is taller that the window height. */
while (start_pos == IT_CHARPOS (it)
&& start_pos > BEGV)
- move_it_by_lines (&it, -1, 1);
+ move_it_by_lines (&it, -1);
}
else if (dy > 0)
{
looking at an image that is taller that the window height. */
while (start_pos == IT_CHARPOS (it)
&& start_pos < ZV)
- move_it_by_lines (&it, 1, 1);
+ move_it_by_lines (&it, 1);
}
}
else
- move_it_by_lines (&it, n, 1);
+ move_it_by_lines (&it, n);
/* We failed if we find ZV is already on the screen (scrolling up,
means there's nothing past the end), or if we can't start any
while (it.current_y < this_scroll_margin)
{
int prev = it.current_y;
- move_it_by_lines (&it, 1, 1);
+ move_it_by_lines (&it, 1);
if (prev == it.current_y)
break;
}
partial_p = it.current_y + it.ascent + it.descent > it.last_visible_y;
else
{
- move_it_by_lines (&it, 1, 1);
+ move_it_by_lines (&it, 1);
partial_p = it.current_y > it.last_visible_y;
}
/* The last line was only partially visible, so back up two
lines to make sure we're on a fully visible line. */
{
- move_it_by_lines (&it, -2, 0);
+ move_it_by_lines (&it, -2);
SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
}
else
if (!NILP (Vscroll_preserve_screen_position))
{
if (window_scroll_preserve_vpos <= 0
- || !SYMBOLP (current_kboard->Vlast_command)
- || NILP (Fget (current_kboard->Vlast_command, Qscroll_command)))
+ || !SYMBOLP (KVAR (current_kboard, Vlast_command))
+ || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
{
struct position posit
= *compute_motion (startpos, 0, 0, 0,
}
-DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
+DEFUE ("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
relative to the selected window. If ARG is negative, it counts up from the
struct buffer *obuf = current_buffer;
int center_p = 0;
EMACS_INT charpos, bytepos;
- int iarg;
+ int iarg IF_LINT (= 0);
int this_scroll_margin;
/* If redisplay is suppressed due to an error, try again. */
start_display (&it, w, pt);
/* Be sure we have the exact height of the full line containing PT. */
- move_it_by_lines (&it, 0, 1);
+ move_it_by_lines (&it, 0);
/* The amount of pixels we have to move back is the window
height minus what's displayed in the line containing PT,
and the lines below. */
it.current_y = 0;
it.vpos = 0;
- move_it_by_lines (&it, nlines, 1);
+ move_it_by_lines (&it, nlines);
if (it.vpos == nlines)
h -= it.current_y;
*/
h += extra_line_spacing;
while (-it.current_y > h)
- move_it_by_lines (&it, 1, 1);
+ move_it_by_lines (&it, 1);
charpos = IT_CHARPOS (it);
bytepos = IT_BYTEPOS (it);
int this_scroll_margin;
#endif
+ if (!(BUFFERP (w->buffer)
+ && XBUFFER (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 (w->start);
if (start < BEGV || start > ZV)
return XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
}
-DEFUN ("set-window-configuration", Fset_window_configuration,
+DEFUE ("set-window-configuration", Fset_window_configuration,
Sset_window_configuration, 1, 1, 0,
doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
CONFIGURATION must be a value previously returned
saved_windows = XVECTOR (data->saved_windows);
new_current_buffer = data->current_buffer;
- if (NILP (XBUFFER (new_current_buffer)->name))
+ if (NILP (BVAR (XBUFFER (new_current_buffer), name)))
new_current_buffer = Qnil;
else
{
w->buffer = p->buffer;
else
{
- if (!NILP (XBUFFER (p->buffer)->name))
+ if (!NILP (BVAR (XBUFFER (p->buffer), name)))
/* If saved buffer is alive, install it. */
{
w->buffer = p->buffer;
w->start_at_line_beg = p->start_at_line_beg;
set_marker_restricted (w->start, p->start, w->buffer);
set_marker_restricted (w->pointm, p->pointm, w->buffer);
- Fset_marker (XBUFFER (w->buffer)->mark,
+ Fset_marker (BVAR (XBUFFER (w->buffer), mark),
p->mark, w->buffer);
/* As documented in Fcurrent_window_configuration, don't
&& XBUFFER (p->buffer) == current_buffer)
Fgoto_char (w->pointm);
}
- else if (NILP (w->buffer) || NILP (XBUFFER (w->buffer)->name))
+ else if (NILP (w->buffer) || NILP (BVAR (XBUFFER (w->buffer), name)))
/* Else unless window has a live buffer, get one. */
{
w->buffer = Fcdr (Fcar (Vbuffer_alist));
}
FRAME_ROOT_WINDOW (f) = data->root_window;
- /* Prevent "swapping out point" in the old selected window
- using the buffer that has been restored into it.
- We already swapped out point that from that window's old buffer. */
- selected_window = Qnil;
/* Arrange *not* to restore point in the buffer that was
current when the window configuration was saved. */
make_number (old_point),
XWINDOW (data->current_window)->buffer);
- Fselect_window (data->current_window, Qnil);
- XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
+ /* 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 (XWINDOW (selected_window)->buffer), last_selected_window)
= selected_window;
if (NILP (data->focus_frame)
&& FRAME_LIVE_P (XFRAME (data->focus_frame))))
Fredirect_frame_focus (frame, data->focus_frame);
-#if 0 /* I don't understand why this is needed, and it causes problems
- when the frame's old selected window has been deleted. */
- if (f != selected_frame && FRAME_WINDOW_P (f))
- do_switch_frame (WINDOW_FRAME (XWINDOW (data->root_window)),
- 0, 0, Qnil);
-#endif
-
/* Set the screen height to the value it had before this function. */
if (previous_frame_lines != FRAME_LINES (f)
|| previous_frame_cols != FRAME_COLS (f))
p->start = Fcopy_marker (w->start, Qnil);
p->start_at_line_beg = w->start_at_line_beg;
- tem = XBUFFER (w->buffer)->mark;
+ tem = BVAR (XBUFFER (w->buffer), mark);
p->mark = Fcopy_marker (tem, Qnil);
}
else
return i;
}
-DEFUN ("current-window-configuration", Fcurrent_window_configuration,
+DEFUE ("current-window-configuration", Fcurrent_window_configuration,
Scurrent_window_configuration, 0, 1, 0,
doc: /* Return an object representing the current window configuration of FRAME.
If FRAME is nil or omitted, use the selected frame.
return (tem);
}
-DEFUN ("save-window-excursion", Fsave_window_excursion, Ssave_window_excursion,
- 0, UNEVALLED, 0,
- doc: /* Execute BODY, preserving window sizes and contents.
-Return the value of the last form in BODY.
-Restore which buffer appears in which window, where display starts,
-and the value of point and mark for each window.
-Also restore the choice of selected window.
-Also restore which buffer is current.
-Does not restore the value of point in current buffer.
-usage: (save-window-excursion BODY...) */)
- (Lisp_Object args)
-{
- register Lisp_Object val;
- register int count = SPECPDL_INDEX ();
-
- record_unwind_protect (Fset_window_configuration,
- Fcurrent_window_configuration (Qnil));
- val = Fprogn (args);
- return unbind_to (count, val);
-}
-
-
\f
/***********************************************************************
Window Split Tree
Fringes
***********************************************************************/
-DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
+DEFUE ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
2, 4, 0,
doc: /* Set the fringe widths of window WINDOW.
If WINDOW is nil, set the fringe widths of the currently selected
Scroll bars
***********************************************************************/
-DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars, Sset_window_scroll_bars,
- 2, 4, 0,
+DEFUE ("set-window-scroll-bars", Fset_window_scroll_bars,
+ Sset_window_scroll_bars, 2, 4, 0,
doc: /* Set width and type of scroll bars of window WINDOW.
If window is nil, set scroll bars of the currently selected window.
Second parameter WIDTH specifies the pixel width for the scroll bar;
first argument being a pointer to the leaf window, and with
additional argument USER_DATA. Stops when FN returns 0. */
-void
-foreach_window (struct frame *f, int (*fn) (struct window *, void *), void *user_data)
+static void
+foreach_window (struct frame *f, int (*fn) (struct window *, void *),
+ void *user_data)
{
/* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
if (WINDOWP (FRAME_ROOT_WINDOW (f)))
window_scroll_preserve_hpos = -1;
window_scroll_preserve_vpos = -1;
- DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
+ DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function,
doc: /* Non-nil means call as function to display a help buffer.
The function is called with one argument, the buffer to be displayed.
Used by `with-output-to-temp-buffer'.
the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
Vtemp_buffer_show_function = Qnil;
- DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window,
+ DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window,
doc: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
Vminibuf_scroll_window = Qnil;
- DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows,
+ DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows,
doc: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
If the minibuffer is active, the `minibuffer-scroll-window' mode line
is displayed in the `mode-line' face. */);
mode_line_in_non_selected_windows = 1;
- DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer,
+ DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer,
doc: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
Vother_window_scroll_buffer = Qnil;
- DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p,
+ DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p,
doc: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
auto_window_vscroll_p = 1;
- DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines,
+ DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines,
doc: /* *Number of lines of continuity when scrolling by screenfuls. */);
next_screen_context_lines = 2;
- DEFVAR_INT ("window-min-height", &window_min_height,
+ DEFVAR_INT ("window-min-height", window_min_height,
doc: /* Allow deleting windows less than this tall.
The value is measured in line units. If a window wants a modeline it
is counted as one line.
windows vertically. A value less than 1 is invalid. */);
window_min_height = 4;
- DEFVAR_INT ("window-min-width", &window_min_width,
+ DEFVAR_INT ("window-min-width", window_min_width,
doc: /* Allow deleting windows less than this wide.
The value is measured in characters and includes any fringes or
the scrollbar.
window_min_width = 10;
DEFVAR_LISP ("scroll-preserve-screen-position",
- &Vscroll_preserve_screen_position,
+ Vscroll_preserve_screen_position,
doc: /* *Controls if scroll commands move point to keep its screen position unchanged.
A value of nil means point does not keep its screen position except
at the scroll margin or window boundary respectively.
on their symbols to be controlled by this variable. */);
Vscroll_preserve_screen_position = Qnil;
- DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type,
+ DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type,
doc: /* Type of marker to use for `window-point'. */);
Vwindow_point_insertion_type = Qnil;
DEFVAR_LISP ("window-configuration-change-hook",
- &Vwindow_configuration_change_hook,
+ Vwindow_configuration_change_hook,
doc: /* Functions to call when window configuration changes.
The buffer-local part is run once per window, with the relevant window
selected; while the global part is run only once for the modified frame,
with the relevant frame selected. */);
Vwindow_configuration_change_hook = Qnil;
- DEFVAR_LISP ("recenter-redisplay", &Vrecenter_redisplay,
+ DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay,
doc: /* If non-nil, then the `recenter' command with a nil argument
will redraw the entire frame; the special value `tty' causes the
frame to be redrawn only if it is a tty frame. */);
defsubr (&Sprevious_window);
defsubr (&Sother_window);
defsubr (&Sget_lru_window);
+ defsubr (&Swindow_use_time);
defsubr (&Sget_largest_window);
defsubr (&Sget_buffer_window);
defsubr (&Sdelete_other_windows);
defsubr (&Sset_window_buffer);
defsubr (&Sselect_window);
defsubr (&Sforce_window_update);
+ defsubr (&Stemp_output_buffer_show);
defsubr (&Ssplit_window);
defsubr (&Senlarge_window);
defsubr (&Sshrink_window);
defsubr (&Swindow_configuration_frame);
defsubr (&Sset_window_configuration);
defsubr (&Scurrent_window_configuration);
- defsubr (&Ssave_window_excursion);
defsubr (&Swindow_tree);
defsubr (&Sset_window_margins);
defsubr (&Swindow_margins);
initial_define_key (meta_map, Ctl ('V'), "scroll-other-window");
initial_define_key (meta_map, 'v', "scroll-down-command");
}
-
-/* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff