/* Window creation, deletion and examination for GNU Emacs.
Does not include redisplay.
- Copyright (C) 1985, 86, 87, 93, 94, 95, 96 Free Software Foundation, Inc.
+ Copyright (C) 1985,86,87,93,94,95,96,97,1998 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "termchar.h"
#include "disptab.h"
#include "keyboard.h"
+#include "blockinput.h"
+#include "dispextern.h"
+#ifdef HAVE_X_WINDOWS
+#include "xterm.h"
+#endif
Lisp_Object Qwindowp, Qwindow_live_p;
-Lisp_Object Fnext_window (), Fdelete_window (), Fselect_window ();
-Lisp_Object Fset_window_buffer (), Fsplit_window (), Frecenter ();
+static struct window *decode_window P_ ((Lisp_Object));
-void delete_all_subwindows ();
-static struct window *decode_window();
+static Lisp_Object select_window_1 P_ ((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
/* Nonzero after init_window_once has finished. */
static int window_initialized;
+/* Hook to run when window config changes. */
+Lisp_Object Qwindow_configuration_change_hook;
+Lisp_Object Vwindow_configuration_change_hook;
+
+/* Nonzero means scroll commands try to put point
+ at the same screen height as previously. */
+static int scroll_preserve_screen_position;
+
+/* Nonzero means we can split a frame even if it is "unsplittable". */
+static int inhibit_frame_unsplittable;
+
#define min(a, b) ((a) < (b) ? (a) : (b))
+extern int scroll_margin;
+
extern Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
\f
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
XSETFASTINT (p->height, 0);
XSETFASTINT (p->width, 0);
XSETFASTINT (p->hscroll, 0);
+ XSETFASTINT (p->last_point, 0);
XSETFASTINT (p->last_point_x, 0);
XSETFASTINT (p->last_point_y, 0);
p->start = Fmake_marker ();
height = XFASTINT (w->height) - ! MINI_WINDOW_P (w);
buf = XBUFFER (w->buffer);
- if (XFASTINT (w->last_modified) >= BUF_MODIFF (buf))
+ if (XFASTINT (w->last_modified) >= BUF_MODIFF (buf)
+ && XFASTINT (w->last_overlay_modified) >= BUF_OVERLAY_MODIFF (buf))
{
/* If frame is up to date,
use the info recorded about how much text fit on it. */
return Qnil;
/* If that info is not correct, calculate afresh */
+ /* BUG FIX for the 7th arg (TOHPOS).
+
+ '0' is harmless, however, ' - (1 << (BITS_PER_SHORT - 1))' is
+ more appropriate here. In case of HSCROLL > 0, this can avoid
+ needless calculation done until (HPOS == 0).
+
+ We want to determine if the position POSINT is in HEIGHT or
+ not. We don't have to do calculation until (HPOS == 0). We
+ can stop it when VPOS goes beyond HEIGHT. */
posval = *compute_motion (top, 0, (hscroll ? 1 - hscroll : 0), 0,
- posint, height, 0,
+ posint, height, - (1 << (BITS_PER_SHORT - 1)),
window_internal_width (w) - 1,
hscroll, 0, w);
register struct window *w = decode_window (window);
return Fcons (w->left, Fcons (w->top,
- Fcons (make_number (XFASTINT (w->left) + XFASTINT (w->width)),
+ Fcons (make_number (WINDOW_RIGHT_EDGE (w)),
Fcons (make_number (XFASTINT (w->top)
+ XFASTINT (w->height)),
Qnil))));
register int *x, *y;
{
register int left = XINT (w->left);
- register int width = XINT (w->width);
+ register int right_edge = WINDOW_RIGHT_EDGE (w);
+ register int left_margin = WINDOW_LEFT_MARGIN (w);
+ register int right_margin = WINDOW_RIGHT_MARGIN (w);
register int window_height = XINT (w->height);
register int top = XFASTINT (w->top);
-
- if ( *x < left || *x >= left + width
+
+ if ( *x < left || *x >= right_edge
|| *y < top || *y >= top + window_height)
return 0;
+ if (left_margin != left && *x < left_margin && *x >= left)
+ return 3;
+
+ if (right_margin != right_edge && *x >= right_margin && *x < right_edge)
+ return 3;
+
/* Is the character is the mode line? */
if (*y == top + window_height - 1
&& ! MINI_WINDOW_P (w))
return 2;
- /* Is the character in the right border? */
- if (*x == left + width - 1
- && left + width != FRAME_WIDTH (XFRAME (w->frame)))
- return 3;
-
- *x -= left;
+ *x -= WINDOW_LEFT_MARGIN (w);
*y -= top;
return 1;
}
return Qnil;
case 1: /* In text part of window. */
- return Fcons (x, y);
+ return Fcons (make_number (x), make_number (y));
case 2: /* In mode line of window. */
return Qmode_line;
(vertical-motion (1- (window-height window)) window)\n\
(point))") */
-DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 1, 0,
+DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0,
"Return position at which display currently ends in WINDOW.\n\
This is updated by redisplay, when it runs to completion.\n\
Simply changing the buffer text or setting `window-start'\n\
-does not update this value.")
- (window)
- Lisp_Object window;
+does not update this value.\n\
+If UP-TO-DATE is non-nil, compute the up-to-date position\n\
+if it isn't already recorded.")
+ (window, update)
+ Lisp_Object window, update;
{
Lisp_Object value;
struct window *w = decode_window (window);
return Qnil;
#endif
- XSETINT (value,
- BUF_Z (XBUFFER (buf)) - XFASTINT (w->window_end_pos));
+ if (! NILP (update)
+ && ! (! NILP (w->window_end_valid)
+ && XFASTINT (w->last_modified) >= MODIFF))
+ {
+ int opoint = PT, opoint_byte = PT_BYTE;
+ TEMP_SET_PT_BOTH (XMARKER (w->start)->charpos,
+ XMARKER (w->start)->bytepos);
+ Fvertical_motion (make_number (window_internal_height (w)), Qnil);
+ XSETINT (value, PT);
+ TEMP_SET_PT_BOTH (opoint, opoint_byte);
+ }
+ else
+ XSETINT (value,
+ BUF_Z (XBUFFER (buf)) - XFASTINT (w->window_end_pos));
return value;
}
w->force_start = Qt;
w->update_mode_line = Qt;
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
if (!EQ (window, selected_window))
windows_or_buffers_changed++;
return pos;
tem = w->display_table;
if (DISP_TABLE_P (tem))
return XCHAR_TABLE (tem);
+ if (NILP (w->buffer))
+ return 0;
+
tem = XBUFFER (w->buffer)->display_table;
if (DISP_TABLE_P (tem))
return XCHAR_TABLE (tem);
\f
/* Record info on buffer window w is displaying
when it is about to cease to display that buffer. */
-static
+static void
unshow_buffer (w)
register struct window *w;
{
Lisp_Object buf;
+ struct buffer *b;
buf = w->buffer;
- if (XBUFFER (buf) != XMARKER (w->pointm)->buffer)
+ b = XBUFFER (buf);
+ if (b != XMARKER (w->pointm)->buffer)
abort ();
- if (w == XWINDOW (XBUFFER (buf)->last_selected_window))
- XBUFFER (buf)->last_selected_window = Qnil;
+ if (w == XWINDOW (b->last_selected_window))
+ b->last_selected_window = Qnil;
#if 0
if (w == XWINDOW (selected_window)
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. */
- XBUFFER (buf)->last_window_start = marker_position (w->start);
+ b->last_window_start = marker_position (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, XWINDOW (selected_window)->buffer))
- BUF_PT (XBUFFER (buf))
- = clip_to_bounds (BUF_BEGV (XBUFFER (buf)),
- marker_position (w->pointm),
- BUF_ZV (XBUFFER (buf)));
+ temp_set_point_both (b,
+ clip_to_bounds (BUF_BEGV (b),
+ XMARKER (w->pointm)->charpos,
+ BUF_ZV (b)),
+ clip_to_bounds (BUF_BEGV_BYTE (b),
+ marker_byte_position (w->pointm),
+ BUF_ZV_BYTE (b)));
}
/* Put replacement into the window structure in place of old. */
-static
+static void
replace_window (old, replacement)
Lisp_Object old, replacement;
{
"Remove WINDOW from the display. Default is selected window.")
(window)
register Lisp_Object window;
+{
+ delete_window (window);
+
+ if (! NILP (Vwindow_configuration_change_hook)
+ && ! NILP (Vrun_hooks))
+ call1 (Vrun_hooks, Qwindow_configuration_change_hook);
+
+ return Qnil;
+}
+
+void
+delete_window (window)
+ register Lisp_Object window;
{
register Lisp_Object tem, parent, sib;
register struct window *p;
if (NILP (p->buffer)
&& NILP (p->hchild)
&& NILP (p->vchild))
- return Qnil;
+ return;
parent = p->parent;
if (NILP (parent))
/* Mark this window as deleted. */
p->buffer = p->hchild = p->vchild = Qnil;
-
- return Qnil;
}
\f
switch (type)
{
case GET_BUFFER_WINDOW:
- if (XBUFFER (XWINDOW (w)->buffer) == XBUFFER (obj))
+ if (XBUFFER (XWINDOW (w)->buffer) == XBUFFER (obj)
+ /* Don't find any minibuffer window
+ except the one that is currently in use. */
+ && (MINI_WINDOW_P (XWINDOW (w))
+ ? EQ (w, minibuf_window) : 1))
return w;
break;
case GET_LRU_WINDOW:
/* t as arg means consider only full-width windows */
- if (!NILP (obj) && XFASTINT (XWINDOW (w)->width)
- != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w)))))
+ if (!NILP (obj) && !WINDOW_FULL_WIDTH_P (XWINDOW (w)))
break;
/* Ignore dedicated windows and minibuffers. */
if (MINI_WINDOW_P (XWINDOW (w))
if (NILP (XWINDOW (w)->parent))
{
Lisp_Object new_buffer;
- new_buffer = Fother_buffer (obj, Qnil);
+ new_buffer = Fother_buffer (obj, Qnil,
+ XWINDOW (w)->frame);
if (NILP (new_buffer))
new_buffer
= Fget_buffer_create (build_string ("*scratch*"));
/* Find another buffer to show in this window. */
Lisp_Object another_buffer;
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (w)));
- another_buffer = Fother_buffer (obj, Qnil);
+ another_buffer = Fother_buffer (obj, Qnil, XWINDOW (w)->frame);
if (NILP (another_buffer))
another_buffer
= Fget_buffer_create (build_string ("*scratch*"));
/* This computation used to temporarily move point, but that can
have unwanted side effects due to text properties. */
pos = *vmotion (startpos, -top, w);
- Fset_marker (w->start, make_number (pos.bufpos), w->buffer);
- w->start_at_line_beg = ((pos.bufpos == BEGV
- || FETCH_CHAR (pos.bufpos - 1) == '\n') ? Qt
+
+ set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
+ w->start_at_line_beg = ((pos.bytepos == BEGV_BYTE
+ || FETCH_BYTE (pos.bytepos - 1) == '\n') ? Qt
: Qnil);
/* We need to do this, so that the window-scroll-functions
get called. */
- w->force_start = Qt;
+ w->optional_new_start = Qt;
set_buffer_internal (obuf);
}
1, 2, "bDelete windows on (buffer): ",
"Delete all windows showing BUFFER.\n\
Optional second argument FRAME controls which frames are affected.\n\
-If nil or omitted, delete all windows showing BUFFER in any frame.\n\
-If t, delete only windows showing BUFFER in the selected frame.\n\
-If `visible', delete all windows showing BUFFER in any visible frame.\n\
-If a frame, delete only windows showing BUFFER in that frame.")
+If optional argument FRAME is `visible', search all visible frames.\n\
+If FRAME is 0, search all visible and iconified frames.\n\
+If FRAME is nil, search all frames.\n\
+If FRAME is t, search only the selected frame.\n\
+If FRAME is a frame, search only that frame.")
(buffer, frame)
Lisp_Object buffer, frame;
{
/* FRAME uses t and nil to mean the opposite of what window_loop
expects. */
- if (! FRAMEP (frame))
- frame = NILP (frame) ? Qt : Qnil;
+ if (NILP (frame))
+ frame = Qt;
+ else if (EQ (frame, Qt))
+ frame = Qnil;
if (!NILP (buffer))
{
because it only considers frames on the current keyboard.
So loop manually over frames, and handle each one. */
FOR_EACH_FRAME (tail, frame)
- window_loop (UNSHOW_BUFFER, buffer, 0, frame);
+ window_loop (UNSHOW_BUFFER, buffer, 1, frame);
#else
- window_loop (UNSHOW_BUFFER, buffer, 0, Qt);
+ window_loop (UNSHOW_BUFFER, buffer, 1, Qt);
#endif
}
\f
nodelete nonzero means do not do this.
(The caller should check later and do so if appropriate) */
+void
set_window_height (window, height, nodelete)
Lisp_Object window;
int height;
if (!nodelete
&& ! NILP (w->parent)
- && height < window_min_height)
+ && (MINI_WINDOW_P (w)
+ ? height < 1
+ : height < window_min_height))
{
- Fdelete_window (window);
+ delete_window (window);
return;
}
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w))) = 1;
/* Recursively set width of WINDOW and its inferiors. */
+void
set_window_width (window, width, nodelete)
Lisp_Object window;
int width;
if (!nodelete && width < window_min_width && !NILP (w->parent))
{
- Fdelete_window (window);
+ delete_window (window);
return;
}
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w))) = 1;
if (EQ (window, selected_window))
XBUFFER (w->buffer)->last_selected_window = window;
+ /* Update time stamps of buffer display. */
+ if (INTEGERP (XBUFFER (buffer)->display_count))
+ XSETINT (XBUFFER (buffer)->display_count,
+ XINT (XBUFFER (buffer)->display_count) + 1);
+ XBUFFER (buffer)->display_time = Fcurrent_time ();
+
XSETFASTINT (w->window_end_pos, 0);
w->window_end_valid = Qnil;
XSETFASTINT (w->hscroll, 0);
- Fset_marker (w->pointm,
- make_number (BUF_PT (XBUFFER (buffer))),
- buffer);
+ set_marker_both (w->pointm, buffer,
+ BUF_PT (XBUFFER (buffer)), BUF_PT_BYTE (XBUFFER (buffer)));
set_marker_restricted (w->start,
make_number (XBUFFER (buffer)->last_window_start),
buffer);
w->start_at_line_beg = Qnil;
w->force_start = Qnil;
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
windows_or_buffers_changed++;
/* We must select BUFFER for running the window-scroll-functions.
run_hook_with_args_2 (Qwindow_scroll_functions, window,
Fmarker_position (w->start));
+ if (! NILP (Vwindow_configuration_change_hook)
+ && ! NILP (Vrun_hooks))
+ call1 (Vrun_hooks, Qwindow_configuration_change_hook);
+
unbind_to (count, Qnil);
return Qnil;
DEFUN ("select-window", Fselect_window, Sselect_window, 1, 1, 0,
"Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
-The main editor command loop selects the buffer of the selected window\n\
-before each command.")
+If WINDOW is not already selected, also make WINDOW's buffer current.\n\
+Note that the main editor command loop\n\
+selects the buffer of the selected window before each command.")
(window)
register Lisp_Object window;
+{
+ return select_window_1 (window, 1);
+}
+\f
+static Lisp_Object
+select_window_1 (window, recordflag)
+ register Lisp_Object window;
+ int recordflag;
{
register struct window *w;
register struct window *ow = XWINDOW (selected_window);
if (EQ (window, selected_window))
return window;
- Fset_marker (ow->pointm, make_number (BUF_PT (XBUFFER (ow->buffer))),
- ow->buffer);
+ if (! NILP (ow->buffer))
+ set_marker_both (ow->pointm, ow->buffer,
+ BUF_PT (XBUFFER (ow->buffer)),
+ BUF_PT_BYTE (XBUFFER (ow->buffer)));
selected_window = window;
if (XFRAME (WINDOW_FRAME (w)) != selected_frame)
else
selected_frame->selected_window = window;
- record_buffer (w->buffer);
+ if (recordflag)
+ record_buffer (w->buffer);
Fset_buffer (w->buffer);
XBUFFER (w->buffer)->last_selected_window = window;
windows_or_buffers_changed++;
return window;
}
-
+\f
/* Deiconify the frame containing the window WINDOW,
unless it is the selected frame;
then return WINDOW.
return window;
}
-DEFUN ("display-buffer", Fdisplay_buffer, Sdisplay_buffer, 1, 2,
- "bDisplay buffer: \nP",
+DEFUN ("special-display-p", Fspecial_display_p, Sspecial_display_p, 1, 1, 0,
+ "Returns non-nil if a buffer named BUFFER-NAME would be created specially.\n\
+The value is actually t if the frame should be called with default frame\n\
+parameters, and a list of frame parameters if they were specified.\n\
+See `special-display-buffer-names', and `special-display-regexps'.")
+ (buffer_name)
+ Lisp_Object buffer_name;
+{
+ Lisp_Object tem;
+
+ CHECK_STRING (buffer_name, 1);
+
+ tem = Fmember (buffer_name, Vspecial_display_buffer_names);
+ if (!NILP (tem))
+ return Qt;
+
+ tem = Fassoc (buffer_name, Vspecial_display_buffer_names);
+ if (!NILP (tem))
+ return XCDR (tem);
+
+ for (tem = Vspecial_display_regexps; CONSP (tem); tem = XCDR (tem))
+ {
+ Lisp_Object car = XCAR (tem);
+ if (STRINGP (car)
+ && fast_string_match (car, buffer_name) >= 0)
+ return Qt;
+ else if (CONSP (car)
+ && STRINGP (XCAR (car))
+ && fast_string_match (XCAR (car), buffer_name) >= 0)
+ return XCDR (car);
+ }
+ return Qnil;
+}
+
+DEFUN ("same-window-p", Fsame_window_p, Ssame_window_p, 1, 1, 0,
+ "Returns non-nil if a new buffer named BUFFER-NAME would use the same window.\n\
+See `same-window-buffer-names' and `same-window-regexps'.")
+ (buffer_name)
+ Lisp_Object buffer_name;
+{
+ Lisp_Object tem;
+
+ CHECK_STRING (buffer_name, 1);
+
+ tem = Fmember (buffer_name, Vsame_window_buffer_names);
+ if (!NILP (tem))
+ return Qt;
+
+ tem = Fassoc (buffer_name, Vsame_window_buffer_names);
+ if (!NILP (tem))
+ return Qt;
+
+ for (tem = Vsame_window_regexps; CONSP (tem); tem = XCDR (tem))
+ {
+ Lisp_Object car = XCAR (tem);
+ if (STRINGP (car)
+ && fast_string_match (car, buffer_name) >= 0)
+ return Qt;
+ else if (CONSP (car)
+ && STRINGP (XCAR (car))
+ && fast_string_match (XCAR (car), buffer_name) >= 0)
+ return Qt;
+ }
+ return Qnil;
+}
+
+ /* Use B so the default is (other-buffer). */
+DEFUN ("display-buffer", Fdisplay_buffer, Sdisplay_buffer, 1, 3,
+ "BDisplay buffer: \nP",
"Make BUFFER appear in some window but don't select it.\n\
BUFFER can be a buffer or a buffer name.\n\
If BUFFER is shown already in some window, just use that one,\n\
\n\
The variables `special-display-buffer-names', `special-display-regexps',\n\
`same-window-buffer-names', and `same-window-regexps' customize how certain\n\
-buffer names are handled.")
- (buffer, not_this_window)
- register Lisp_Object buffer, not_this_window;
+buffer names are handled.\n\
+\n\
+If optional argument FRAME is `visible', search all visible frames.\n\
+If FRAME is 0, search all visible and iconified frames.\n\
+If FRAME is t, search all frames.\n\
+If FRAME is a frame, search only that frame.\n\
+If FRAME is nil, search only the selected frame\n\
+ (actually the last nonminibuffer frame),\n\
+ unless `pop-up-frames' is non-nil,\n\
+ which means search visible and iconified frames.")
+ (buffer, not_this_window, frame)
+ register Lisp_Object buffer, not_this_window, frame;
{
register Lisp_Object window, tem;
in the selected window. */
if (NILP (not_this_window))
{
- tem = Fmember (XBUFFER (buffer)->name, Vsame_window_buffer_names);
+ tem = Fsame_window_p (XBUFFER (buffer)->name);
if (!NILP (tem))
{
Fswitch_to_buffer (buffer, Qnil);
return display_buffer_1 (selected_window);
}
-
- tem = Fassoc (XBUFFER (buffer)->name, Vsame_window_buffer_names);
- if (!NILP (tem))
- {
- Fswitch_to_buffer (buffer, Qnil);
- return display_buffer_1 (selected_window);
- }
-
- for (tem = Vsame_window_regexps; CONSP (tem); tem = XCONS (tem)->cdr)
- {
- Lisp_Object car = XCONS (tem)->car;
- if (STRINGP (car)
- && fast_string_match (car, XBUFFER (buffer)->name) >= 0)
- {
- Fswitch_to_buffer (buffer, Qnil);
- return display_buffer_1 (selected_window);
- }
- else if (CONSP (car)
- && STRINGP (XCONS (car)->car)
- && fast_string_match (XCONS (car)->car,
- XBUFFER (buffer)->name) >= 0)
- {
- Fswitch_to_buffer (buffer, Qnil);
- return display_buffer_1 (selected_window);
- }
- }
}
/* If pop_up_frames,
look for a window showing BUFFER on any visible or iconified frame.
Otherwise search only the current frame. */
- if (pop_up_frames || last_nonminibuf_frame == 0)
+ if (! NILP (frame))
+ tem = frame;
+ else if (pop_up_frames || last_nonminibuf_frame == 0)
XSETFASTINT (tem, 0);
else
XSETFRAME (tem, last_nonminibuf_frame);
}
/* Certain buffer names get special handling. */
- if (! NILP (Vspecial_display_function))
+ if (!NILP (Vspecial_display_function))
{
- tem = Fmember (XBUFFER (buffer)->name, Vspecial_display_buffer_names);
- if (!NILP (tem))
+ tem = Fspecial_display_p (XBUFFER (buffer)->name);
+ if (EQ (tem, Qt))
return call1 (Vspecial_display_function, buffer);
-
- tem = Fassoc (XBUFFER (buffer)->name, Vspecial_display_buffer_names);
- if (!NILP (tem))
- return call2 (Vspecial_display_function, buffer, XCONS (tem)->cdr);
-
- for (tem = Vspecial_display_regexps; CONSP (tem); tem = XCONS (tem)->cdr)
- {
- Lisp_Object car = XCONS (tem)->car;
- if (STRINGP (car)
- && fast_string_match (car, XBUFFER (buffer)->name) >= 0)
- return call1 (Vspecial_display_function, buffer);
- else if (CONSP (car)
- && STRINGP (XCONS (car)->car)
- && fast_string_match (XCONS (car)->car,
- XBUFFER (buffer)->name) >= 0)
- return call2 (Vspecial_display_function,
- buffer,
- XCONS (car)->cdr);
- }
+ if (CONSP (tem))
+ return call2 (Vspecial_display_function, buffer, tem);
}
/* If there are no frames open that have more than a minibuffer,
if (!NILP (window)
&& ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window)->frame))
&& window_height (window) >= split_height_threshold
- && (XFASTINT (XWINDOW (window)->width)
- == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window))))))
+ && WINDOW_FULL_WIDTH_P (XWINDOW (window)))
window = Fsplit_window (window, Qnil, Qnil);
else
{
&& window_height (window) >= window_min_height << 1)
window = Fsplit_window (window, Qnil, Qnil);
/* If Fget_lru_window returned nil, try other approaches. */
+
/* Try visible frames first. */
+ if (NILP (window))
+ window = Fget_buffer_window (buffer, Qvisible);
if (NILP (window))
window = Fget_largest_window (Qvisible);
/* If that didn't work, try iconified frames. */
+ if (NILP (window))
+ window = Fget_buffer_window (buffer, make_number (0));
if (NILP (window))
window = Fget_largest_window (make_number (0));
/* Try invisible frames. */
+ if (NILP (window))
+ window = Fget_buffer_window (buffer, Qt);
if (NILP (window))
window = Fget_largest_window (Qt);
/* As a last resort, make a new frame. */
other = lower = XWINDOW (window)->next, upper = window;
if (!NILP (other)
/* Check that OTHER and WINDOW are vertically arrayed. */
- && XWINDOW (other)->top != XWINDOW (window)->top
- && XWINDOW (other)->height > XWINDOW (window)->height)
+ && !EQ (XWINDOW (other)->top, XWINDOW (window)->top)
+ && (XFASTINT (XWINDOW (other)->height)
+ > XFASTINT (XWINDOW (window)->height)))
{
- int total = XWINDOW (other)->height + XWINDOW (window)->height;
+ int total = (XFASTINT (XWINDOW (other)->height)
+ + XFASTINT (XWINDOW (window)->height));
Lisp_Object old_selected_window;
old_selected_window = selected_window;
selected_window = upper;
- change_window_height (total / 2 - XWINDOW (upper)->height, 0);
+ change_window_height ((total / 2
+ - XFASTINT (XWINDOW (upper)->height)),
+ 0);
selected_window = old_selected_window;
}
}
register Lisp_Object window;
register struct window *w;
+ XBUFFER (buf)->directory = current_buffer->directory;
+
Fset_buffer (buf);
BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
BEGV = BEG;
call1 (Vtemp_buffer_show_function, buf);
else
{
- window = Fdisplay_buffer (buf, Qnil);
+ window = Fdisplay_buffer (buf, Qnil, Qnil);
if (XFRAME (XWINDOW (window)->frame) != selected_frame)
Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
Vminibuf_scroll_window = window;
w = XWINDOW (window);
XSETFASTINT (w->hscroll, 0);
- set_marker_restricted (w->start, make_number (1), buf);
- set_marker_restricted (w->pointm, make_number (1), buf);
+ set_marker_restricted_both (w->start, buf, 1, 1);
+ set_marker_restricted_both (w->pointm, buf, 1, 1);
- /* Run temp-buffer-show-hook, with the chosen window selected. */
+ /* Run temp-buffer-show-hook, with the chosen window selected
+ and it sbuffer current. */
if (!NILP (Vrun_hooks))
{
Lisp_Object tem;
if (!NILP (tem))
{
int count = specpdl_ptr - specpdl;
+ Lisp_Object prev_window;
+ prev_window = selected_window;
/* Select the window that was chosen, for running the hook. */
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (Qnil));
- Fselect_window (window);
+ select_window_1 (window, 0);
+ Fset_buffer (w->buffer);
call1 (Vrun_hooks, Qtemp_buffer_show_hook);
+ select_window_1 (prev_window, 0);
unbind_to (count, Qnil);
}
}
}
}
\f
-static
+static void
make_dummy_parent (window)
Lisp_Object window;
{
if (MINI_WINDOW_P (o))
error ("Attempt to split minibuffer window");
- else if (FRAME_NO_SPLIT_P (fo))
- error ("Attempt to split unsplittable frame");
check_min_window_sizes ();
p->parent = o->parent;
p->buffer = Qt;
- Fset_window_buffer (new, o->buffer);
-
/* Apportion the available frame space among the two new windows */
if (!NILP (horflag))
XSETFASTINT (p->top, XFASTINT (o->top) + size_int);
}
+ Fset_window_buffer (new, o->buffer);
+
return new;
}
\f
{
CHECK_NUMBER (arg, 0);
change_window_height (XINT (arg), !NILP (side));
+
+ if (! NILP (Vwindow_configuration_change_hook))
+ call1 (Vrun_hooks, Qwindow_configuration_change_hook);
+
return Qnil;
}
{
CHECK_NUMBER (arg, 0);
change_window_height (-XINT (arg), !NILP (side));
+
+ if (! NILP (Vwindow_configuration_change_hook))
+ call1 (Vrun_hooks, Qwindow_configuration_change_hook);
+
return Qnil;
}
also changes the heights of the siblings so as to
keep everything consistent. */
+void
change_window_height (delta, widthflag)
register int delta;
int widthflag;
Lisp_Object window;
register struct window *p;
int *sizep;
- int (*sizefun) () = widthflag ? window_width : window_height;
- register int (*setsizefun) () = (widthflag
- ? set_window_width
- : set_window_height);
+ int (*sizefun) P_ ((Lisp_Object))
+ = widthflag ? window_width : window_height;
+ register void (*setsizefun) P_ ((Lisp_Object, int, int))
+ = (widthflag ? set_window_width : set_window_height);
+ int maximum;
+ Lisp_Object next, prev;
check_min_window_sizes ();
if (*sizep + delta < MINSIZE (window))
{
- Fdelete_window (window);
+ delete_window (window);
return;
}
if (delta == 0)
return;
- if (!NILP (p->next)
- && (*sizefun) (p->next) - delta >= MINSIZE (p->next))
- {
- (*setsizefun) (p->next, (*sizefun) (p->next) - delta, 0);
- (*setsizefun) (window, *sizep + delta, 0);
- CURBEG (p->next) += delta;
- /* This does not change size of p->next,
- but it propagates the new top edge to its children */
- (*setsizefun) (p->next, (*sizefun) (p->next), 0);
- }
- else if (!NILP (p->prev)
- && (*sizefun) (p->prev) - delta >= MINSIZE (p->prev))
+ /* Find the total we can get from other siblings. */
+ maximum = 0;
+ for (next = p->next; ! NILP (next); next = XWINDOW (next)->next)
+ maximum += (*sizefun) (next) - MINSIZE (next);
+ for (prev = p->prev; ! NILP (prev); prev = XWINDOW (prev)->prev)
+ maximum += (*sizefun) (prev) - MINSIZE (prev);
+
+ /* If we can get it all from them, do so. */
+ if (delta <= maximum)
{
- (*setsizefun) (p->prev, (*sizefun) (p->prev) - delta, 0);
- CURBEG (window) -= delta;
- (*setsizefun) (window, *sizep + delta, 0);
+ Lisp_Object first_unaffected;
+ Lisp_Object first_affected;
+
+ next = p->next;
+ prev = p->prev;
+ first_affected = window;
+ /* Look at one sibling at a time,
+ moving away from this window in both directions alternately,
+ and take as much as we can get without deleting that sibling. */
+ while (delta != 0)
+ {
+ if (delta == 0)
+ break;
+ if (! NILP (next))
+ {
+ int this_one = (*sizefun) (next) - MINSIZE (next);
+ if (this_one > delta)
+ this_one = delta;
+
+ (*setsizefun) (next, (*sizefun) (next) - this_one, 0);
+ (*setsizefun) (window, *sizep + this_one, 0);
+
+ delta -= this_one;
+ next = XWINDOW (next)->next;
+ }
+ if (delta == 0)
+ break;
+ if (! NILP (prev))
+ {
+ int this_one = (*sizefun) (prev) - MINSIZE (prev);
+ if (this_one > delta)
+ this_one = delta;
+
+ first_affected = prev;
+
+ (*setsizefun) (prev, (*sizefun) (prev) - this_one, 0);
+ (*setsizefun) (window, *sizep + this_one, 0);
+
+ delta -= this_one;
+ prev = XWINDOW (prev)->prev;
+ }
+ }
+
+ /* Now recalculate the edge positions of all the windows affected,
+ based on the new sizes. */
+ first_unaffected = next;
+ prev = first_affected;
+ for (next = XWINDOW (prev)->next; ! EQ (next, first_unaffected);
+ prev = next, next = XWINDOW (next)->next)
+ {
+ CURBEG (next) = CURBEG (prev) + (*sizefun) (prev);
+ /* This does not change size of NEXT,
+ but it propagates the new top edge to its children */
+ (*setsizefun) (next, (*sizefun) (next), 0);
+ }
}
else
{
}
XSETFASTINT (p->last_modified, 0);
+ XSETFASTINT (p->last_overlay_modified, 0);
}
#undef MINSIZE
#undef CURBEG
struct window *w;
{
FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
- int left = XINT (w->left);
int width = XINT (w->width);
- /* If this window is flush against the right edge of the frame, its
- internal width is its full width. */
- if (left + width >= FRAME_WIDTH (f))
- return width;
-
- /* If we are not flush right, then our rightmost columns are
- occupied by some sort of separator. */
-
/* Scroll bars occupy a few columns. */
if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
return width - FRAME_SCROLL_BAR_COLS (f);
/* The column of `|' characters separating side-by-side windows
occupies one column only. */
- return width - 1;
+ if (!WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
+ return width - 1;
+
+ return width;
}
-/* Scroll contents of window WINDOW up N lines. */
+/* Scroll contents of window WINDOW up N lines.
+ If WHOLE is nonzero, it means scroll N screenfuls instead. */
-void
-window_scroll (window, n, noerror)
+static void
+window_scroll (window, n, whole, noerror)
Lisp_Object window;
int n;
+ int whole;
int noerror;
{
register struct window *w = XWINDOW (window);
register int opoint = PT;
- register int pos;
+ register int opoint_byte = PT_BYTE;
+ register int pos, pos_byte;
register int ht = window_internal_height (w);
register Lisp_Object tem;
int lose;
Lisp_Object bolp, nmoved;
+ int startpos;
+ struct position posit;
+ int original_vpos;
- /* Always set force_start so that redisplay_window will run
- the window-scroll-functions. */
- w->force_start = Qt;
+ startpos = marker_position (w->start);
+
+ posit = *compute_motion (startpos, 0, 0, 0,
+ PT, ht, 0,
+ window_internal_width (w), XINT (w->hscroll),
+ 0, w);
+ original_vpos = posit.vpos;
XSETFASTINT (tem, PT);
tem = Fpos_visible_in_window_p (tem, window);
if (NILP (tem))
{
Fvertical_motion (make_number (- (ht / 2)), window);
- XSETFASTINT (tem, PT);
- Fset_marker (w->start, tem, w->buffer);
+ startpos = PT;
}
- SET_PT (marker_position (w->start));
+ SET_PT (startpos);
lose = n < 0 && PT == BEGV;
Fvertical_motion (make_number (n), window);
pos = PT;
+ pos_byte = PT_BYTE;
bolp = Fbolp ();
- SET_PT (opoint);
+ SET_PT_BOTH (opoint, opoint_byte);
if (lose)
{
if (pos < ZV)
{
- set_marker_restricted (w->start, make_number (pos), w->buffer);
+ int this_scroll_margin = scroll_margin;
+
+ /* Don't use a scroll margin that is negative or too large. */
+ if (this_scroll_margin < 0)
+ this_scroll_margin = 0;
+
+ if (XINT (w->height) < 4 * scroll_margin)
+ this_scroll_margin = XINT (w->height) / 4;
+
+ set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
w->start_at_line_beg = bolp;
w->update_mode_line = Qt;
XSETFASTINT (w->last_modified, 0);
- if (pos > opoint)
- SET_PT (pos);
- if (n < 0)
+ XSETFASTINT (w->last_overlay_modified, 0);
+ /* Set force_start so that redisplay_window will run
+ the window-scroll-functions. */
+ w->force_start = Qt;
+
+ if (whole && scroll_preserve_screen_position)
+ {
+ SET_PT_BOTH (pos, pos_byte);
+ Fvertical_motion (make_number (original_vpos), window);
+ }
+ /* If we scrolled forward, put point enough lines down
+ that it is outside the scroll margin. */
+ else if (n > 0)
+ {
+ int top_margin;
+
+ if (this_scroll_margin > 0)
+ {
+ SET_PT_BOTH (pos, pos_byte);
+ Fvertical_motion (make_number (this_scroll_margin), window);
+ top_margin = PT;
+ }
+ else
+ top_margin = pos;
+
+ if (top_margin <= opoint)
+ SET_PT_BOTH (opoint, opoint_byte);
+ else if (scroll_preserve_screen_position)
+ {
+ SET_PT_BOTH (pos, pos_byte);
+ Fvertical_motion (make_number (original_vpos), window);
+ }
+ else
+ SET_PT (top_margin);
+ }
+ else if (n < 0)
{
- SET_PT (pos);
- tem = Fvertical_motion (make_number (ht), window);
- if (PT > opoint || XFASTINT (tem) < ht)
- SET_PT (opoint);
+ int bottom_margin;
+
+ /* If we scrolled backward, put point near the end of the window
+ but not within the scroll margin. */
+ SET_PT_BOTH (pos, pos_byte);
+ tem = Fvertical_motion (make_number (ht - this_scroll_margin), window);
+ if (XFASTINT (tem) == ht - this_scroll_margin)
+ bottom_margin = PT;
+ else
+ bottom_margin = PT + 1;
+
+ if (bottom_margin > opoint)
+ SET_PT_BOTH (opoint, opoint_byte);
else
- Fvertical_motion (make_number (-1), window);
+ {
+ if (scroll_preserve_screen_position)
+ {
+ SET_PT_BOTH (pos, pos_byte);
+ Fvertical_motion (make_number (original_vpos), window);
+ }
+ else
+ Fvertical_motion (make_number (-1), window);
+ }
}
}
else
defalt = direction * (defalt < 1 ? 1 : defalt);
if (NILP (n))
- window_scroll (selected_window, defalt, 0);
+ window_scroll (selected_window, defalt, 1, 0);
else if (EQ (n, Qminus))
- window_scroll (selected_window, - defalt, 0);
+ window_scroll (selected_window, - defalt, 1, 0);
else
{
n = Fprefix_numeric_value (n);
- window_scroll (selected_window, XINT (n) * direction, 0);
+ window_scroll (selected_window, XINT (n) * direction, 0, 0);
}
unbind_to (count, Qnil);
"Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
A near full screen is `next-screen-context-lines' less than a full screen.\n\
Negative ARG means scroll downward.\n\
-When calling from a program, supply a number as argument or nil.")
+If ARG is the atom `-', scroll downward by nearly full screen.\n\
+When calling from a program, supply as argument a number, nil, or `-'.")
(arg)
Lisp_Object arg;
{
}
DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "P",
- "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
+ "Scroll text of current window down ARG lines; or near full screen if no ARG.\n\
A near full screen is `next-screen-context-lines' less than a full screen.\n\
Negative ARG means scroll upward.\n\
-When calling from a program, supply a number as argument or nil.")
+If ARG is the atom `-', scroll upward by nearly full screen.\n\
+When calling from a program, supply as argument a number, nil, or `-'.")
(arg)
Lisp_Object arg;
{
{
window = Fget_buffer_window (Vother_window_scroll_buffer, Qnil);
if (NILP (window))
- window = Fdisplay_buffer (Vother_window_scroll_buffer, Qt);
+ window = Fdisplay_buffer (Vother_window_scroll_buffer, Qt, Qnil);
}
else
{
DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "P",
"Scroll next window upward ARG lines; or near full screen if no ARG.\n\
+A near full screen is `next-screen-context-lines' less than a full screen.\n\
The next window is the one below the current one; or the one at the top\n\
if the current one is at the bottom. Negative ARG means scroll downward.\n\
-When calling from a program, supply a number as argument or nil.\n\
+If ARG is the atom `-', scroll downward by nearly full screen.\n\
+When calling from a program, supply as argument a number, nil, or `-'.\n\
\n\
If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
specifies the window to scroll.\n\
SET_PT (marker_position (w->pointm));
if (NILP (arg))
- window_scroll (window, defalt, 1);
+ window_scroll (window, defalt, 1, 1);
else if (EQ (arg, Qminus))
- window_scroll (window, -defalt, 1);
+ window_scroll (window, -defalt, 1, 1);
else
{
if (CONSP (arg))
arg = Fcar (arg);
CHECK_NUMBER (arg, 0);
- window_scroll (window, XINT (arg), 1);
+ window_scroll (window, XINT (arg), 0, 1);
}
- Fset_marker (w->pointm, make_number (PT), Qnil);
+ set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
unbind_to (count, Qnil);
return Qnil;
register struct window *w = XWINDOW (selected_window);
register int ht = window_internal_height (w);
struct position pos;
+ struct buffer *buf = XBUFFER (w->buffer);
+ struct buffer *obuf = current_buffer;
if (NILP (arg))
{
if (XINT (arg) < 0)
XSETINT (arg, XINT (arg) + ht);
+ set_buffer_internal (buf);
pos = *vmotion (PT, - XINT (arg), w);
- Fset_marker (w->start, make_number (pos.bufpos), w->buffer);
- w->start_at_line_beg = ((pos.bufpos == BEGV
- || FETCH_CHAR (pos.bufpos - 1) == '\n')
+ set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
+ w->start_at_line_beg = ((pos.bytepos == BEGV_BYTE
+ || FETCH_BYTE (pos.bytepos - 1) == '\n')
? Qt : Qnil);
w->force_start = Qt;
+ set_buffer_internal (obuf);
return Qnil;
}
if (start < BEGV || start > ZV)
{
Fvertical_motion (make_number (- (height / 2)), window);
- Fset_marker (w->start, make_number (PT), w->buffer);
+ set_marker_both (w->start, w->buffer, PT, PT_BYTE);
w->start_at_line_beg = Fbolp ();
w->force_start = Qt;
}
else
- SET_PT (start);
+ Fgoto_char (w->start);
return Fvertical_motion (arg, window);
}
/* Record the values of window-min-width and window-min-height
so that window sizes remain consistent with them. */
Lisp_Object min_width, min_height;
- /* A vector, interpreted as a struct saved_window */
+ /* A vector, each of whose elements is a struct saved_window
+ for one window. */
Lisp_Object saved_windows;
};
-/* This is saved as a Lisp_Vector */
+/* This is saved as a Lisp_Vector */
struct saved_window
{
/* these first two must agree with struct Lisp_Vector in lisp.h */
((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
- "T if OBJECT is a window-configuration object.")
+ "Return t if OBJECT is a window-configuration object.")
(object)
Lisp_Object object;
{
return Qnil;
}
-
DEFUN ("set-window-configuration", Fset_window_configuration,
Sset_window_configuration, 1, 1, 0,
"Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
Lisp_Object new_current_buffer;
Lisp_Object frame;
FRAME_PTR f;
+ int old_point = -1;
while (!WINDOW_CONFIGURATIONP (configuration))
{
new_current_buffer = data->current_buffer;
if (NILP (XBUFFER (new_current_buffer)->name))
new_current_buffer = Qnil;
+ else
+ {
+ if (XBUFFER (new_current_buffer) == current_buffer)
+ old_point = PT;
+
+ }
frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
f = XFRAME (frame);
int previous_frame_width = FRAME_WIDTH (f);
int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
+ /* The mouse highlighting code could get screwed up
+ if it runs during this. */
+ BLOCK_INPUT;
+
if (XFASTINT (data->frame_height) != previous_frame_height
|| XFASTINT (data->frame_width) != previous_frame_width)
- change_frame_size (f, data->frame_height, data->frame_width, 0, 0);
+ change_frame_size (f, XFASTINT (data->frame_height),
+ XFASTINT (data->frame_width), 0, 0);
#if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
if (XFASTINT (data->frame_menu_bar_lines)
!= previous_frame_menu_bar_lines)
- x_set_menu_bar_lines (f, data->frame_menu_bar_lines, 0);
+ x_set_menu_bar_lines (f, data->frame_menu_bar_lines, make_number (0));
#endif
+ if (! NILP (XWINDOW (selected_window)->buffer))
+ {
+ w = XWINDOW (selected_window);
+ set_marker_both (w->pointm,
+ w->buffer,
+ BUF_PT (XBUFFER (w->buffer)),
+ BUF_PT_BYTE (XBUFFER (w->buffer)));
+ }
+
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
w->hscroll = p->hscroll;
w->display_table = p->display_table;
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
/* Reinstall the saved buffer and pointers into it. */
if (NILP (p->buffer))
{
w->buffer = p->buffer;
w->start_at_line_beg = p->start_at_line_beg;
- set_marker_restricted (w->start,
- Fmarker_position (p->start),
- w->buffer);
- set_marker_restricted (w->pointm,
- Fmarker_position (p->pointm),
- w->buffer);
+ set_marker_restricted (w->start, p->start, w->buffer);
+ set_marker_restricted (w->pointm, p->pointm, w->buffer);
Fset_marker (XBUFFER (w->buffer)->mark,
- Fmarker_position (p->mark), w->buffer);
+ p->mark, w->buffer);
/* As documented in Fcurrent_window_configuration, don't
save the location of point in the buffer which was current
set_marker_restricted (w->start, make_number (0),
w->buffer);
if (XMARKER (w->pointm)->buffer == 0)
- set_marker_restricted (w->pointm,
- (make_number
- (BUF_PT (XBUFFER (w->buffer)))),
- w->buffer);
+ set_marker_restricted_both (w->pointm, w->buffer,
+ BUF_PT (XBUFFER (w->buffer)),
+ BUF_PT_BYTE (XBUFFER (w->buffer)));
w->start_at_line_beg = Qt;
}
}
FRAME_ROOT_WINDOW (f) = data->root_window;
Fselect_window (data->current_window);
+ XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
+ = selected_window;
if (NILP (data->focus_frame)
|| (FRAMEP (data->focus_frame)
0, 0);
#if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
- x_set_menu_bar_lines (f, previous_frame_menu_bar_lines, 0);
+ x_set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
+ make_number (0));
#endif
+
+ UNBLOCK_INPUT;
+
+ /* Fselect_window will have made f the selected frame, so we
+ reselect the proper frame here. Fhandle_switch_frame will change the
+ selected window too, but that doesn't make the call to
+ Fselect_window above totally superfluous; it still sets f's
+ selected window. */
+ if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
+ do_switch_frame (data->selected_frame, Qnil, 0);
+
+ if (! NILP (Vwindow_configuration_change_hook)
+ && ! NILP (Vrun_hooks))
+ call1 (Vrun_hooks, Qwindow_configuration_change_hook);
+ }
+
+ if (!NILP (new_current_buffer))
+ {
+ Fset_buffer (new_current_buffer);
+
+ /* If the buffer that is current now is the same
+ that was current before setting the window configuration,
+ don't alter its PT. */
+ if (old_point >= 0)
+ SET_PT (old_point);
}
/* Restore the minimum heights recorded in the configuration. */
window_min_height = XINT (data->min_height);
window_min_width = XINT (data->min_width);
- /* Fselect_window will have made f the selected frame, so we
- reselect the proper frame here. Fhandle_switch_frame will change the
- selected window too, but that doesn't make the call to
- Fselect_window above totally superfluous; it still sets f's
- selected window. */
- if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
- do_switch_frame (data->selected_frame, Qnil, 0);
-
- if (!NILP (new_current_buffer))
- Fset_buffer (new_current_buffer);
-
Vminibuf_scroll_window = data->minibuf_scroll_window;
- return (Qnil);
+
+ return Qnil;
}
/* Mark all windows now on frame as deleted
if (EQ (window, selected_window))
{
p->pointm = Fmake_marker ();
- Fset_marker (p->pointm, BUF_PT (XBUFFER (w->buffer)),
- w->buffer);
+ set_marker_both (p->pointm, w->buffer,
+ BUF_PT (XBUFFER (w->buffer)),
+ BUF_PT_BYTE (XBUFFER (w->buffer)));
}
else
p->pointm = Fcopy_marker (w->pointm, Qnil);
return i;
}
-DEFUN ("current-window-configuration",
- Fcurrent_window_configuration, Scurrent_window_configuration, 0, 1, 0,
+DEFUN ("current-window-configuration", Fcurrent_window_configuration,
+ Scurrent_window_configuration, 0, 1, 0,
"Return an object representing the current window configuration of FRAME.\n\
If FRAME is nil or omitted, use the selected frame.\n\
This describes the number of windows, their sizes and current buffers,\n\
return unbind_to (count, val);
}
\f
+/* Return 1 if window configurations C1 and C2
+ describe the same state of affairs. This is used by Fequal. */
+
+int
+compare_window_configurations (c1, c2, ignore_positions)
+ Lisp_Object c1, c2;
+ int ignore_positions;
+{
+ register struct save_window_data *d1, *d2;
+ struct Lisp_Vector *sw1, *sw2;
+ int i;
+
+ d1 = (struct save_window_data *) XVECTOR (c1);
+ d2 = (struct save_window_data *) XVECTOR (c2);
+ sw1 = XVECTOR (d1->saved_windows);
+ sw2 = XVECTOR (d2->saved_windows);
+
+ if (! EQ (d1->frame_width, d2->frame_width))
+ return 0;
+ if (! EQ (d1->frame_height, d2->frame_height))
+ return 0;
+ if (! EQ (d1->frame_menu_bar_lines, d2->frame_menu_bar_lines))
+ return 0;
+ if (! EQ (d1->selected_frame, d2->selected_frame))
+ return 0;
+ /* Don't compare the current_window field directly.
+ Instead see w1_is_current and w2_is_current, below. */
+ if (! EQ (d1->current_buffer, d2->current_buffer))
+ return 0;
+ if (! ignore_positions)
+ if (! EQ (d1->minibuf_scroll_window, d2->minibuf_scroll_window))
+ return 0;
+ /* Don't compare the root_window field.
+ We don't require the two configurations
+ to use the same window object,
+ and the two root windows must be equivalent
+ if everything else compares equal. */
+ if (! EQ (d1->focus_frame, d2->focus_frame))
+ return 0;
+ if (! EQ (d1->min_width, d2->min_width))
+ return 0;
+ if (! EQ (d1->min_height, d2->min_height))
+ return 0;
+
+ /* Verify that the two confis have the same number of windows. */
+ if (sw1->size != sw2->size)
+ return 0;
+
+ for (i = 0; i < sw1->size; i++)
+ {
+ struct saved_window *p1, *p2;
+ int w1_is_current, w2_is_current;
+
+ p1 = SAVED_WINDOW_N (sw1, i);
+ p2 = SAVED_WINDOW_N (sw2, i);
+
+ /* Verify that the current windows in the two
+ configurations correspond to each other. */
+ w1_is_current = EQ (d1->current_window, p1->window);
+ w2_is_current = EQ (d2->current_window, p2->window);
+
+ if (w1_is_current != w2_is_current)
+ return 0;
+
+ /* Verify that the corresponding windows do match. */
+ if (! EQ (p1->buffer, p2->buffer))
+ return 0;
+ if (! EQ (p1->left, p2->left))
+ return 0;
+ if (! EQ (p1->top, p2->top))
+ return 0;
+ if (! EQ (p1->width, p2->width))
+ return 0;
+ if (! EQ (p1->height, p2->height))
+ return 0;
+ if (! EQ (p1->display_table, p2->display_table))
+ return 0;
+ if (! EQ (p1->parent, p2->parent))
+ return 0;
+ if (! EQ (p1->prev, p2->prev))
+ return 0;
+ if (! ignore_positions)
+ {
+ if (! EQ (p1->hscroll, p2->hscroll))
+ return 0;
+ if (! EQ (p1->start_at_line_beg, p2->start_at_line_beg))
+ return 0;
+ if (NILP (Fequal (p1->start, p2->start)))
+ return 0;
+ if (NILP (Fequal (p1->pointm, p2->pointm)))
+ return 0;
+ if (NILP (Fequal (p1->mark, p2->mark)))
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+DEFUN ("compare-window-configurations", Fcompare_window_configurations,
+ Scompare_window_configurations, 2, 2, 0,
+ "Compare two window configurations as regards the structure of windows.\n\
+This function ignores details such as the values of point and mark\n\
+and scrolling positions.")
+ (x, y)
+ Lisp_Object x, y;
+{
+ if (compare_window_configurations (x, y, 1))
+ return Qt;
+ return Qnil;
+}
+\f
+void
init_window_once ()
{
selected_frame = make_terminal_frame ();
window_initialized = 1;
}
+void
syms_of_window ()
{
+ staticpro (&Qwindow_configuration_change_hook);
+ Qwindow_configuration_change_hook
+ = intern ("window-configuration-change-hook");
+
Qwindowp = intern ("windowp");
staticpro (&Qwindowp);
DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names,
"*List of buffer names that should have their own special frames.\n\
Displaying a buffer whose name is in this list makes a special frame for it\n\
-using `special-display-function'.\n\
+using `special-display-function'. See also `special-display-regexps'.\n\
\n\
-An element of the list can be a cons cell instead of just a string.\n\
-Then the car should be a buffer name, and the cdr specifies frame\n\
-parameters for creating the frame for that buffer.\n\
-More precisely, the cdr is passed as the second argument to\n\
-the function found in `special-display-function', when making that frame.\n\
-See also `special-display-regexps'.");
+An element of the list can be a list instead of just a string.\n\
+There are two ways to use a list as an element:\n\
+ (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)\n\
+In the first case, FRAME-PARAMETERS are used to create the frame.\n\
+In the latter case, FUNCTION is called with BUFFER as the first argument,\n\
+followed by OTHER-ARGS--it can display BUFFER in any way it likes.\n\
+All this is done by the function found in `special-display-function'.\n\
+\n\
+If this variable appears \"not to work\", because you add a name to it\n\
+but that buffer still appears in the selected window, look at the\n\
+values of `same-window-buffer-names' and `same-window-regexps'.\n\
+Those variables take precedence over this one.");
Vspecial_display_buffer_names = Qnil;
DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps,
Displaying a buffer whose name is in this list makes a special frame for it\n\
using `special-display-function'.\n\
\n\
-An element of the list can be a cons cell instead of just a string.\n\
-Then the car should be the regexp, and the cdr specifies frame\n\
-parameters for creating the frame for buffers that match.\n\
-More precisely, the cdr is passed as the second argument to\n\
-the function found in `special-display-function', when making that frame.\n\
-See also `special-display-buffer-names'.");
+An element of the list can be a list instead of just a string.\n\
+There are two ways to use a list as an element:\n\
+ (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)\n\
+In the first case, FRAME-PARAMETERS are used to create the frame.\n\
+In the latter case, FUNCTION is called with the buffer as first argument,\n\
+followed by OTHER-ARGS--it can display the buffer in any way it likes.\n\
+All this is done by the function found in `special-display-function'.\n\
+\n\
+If this variable appears \"not to work\", because you add a regexp to it\n\
+but the matching buffers still appear in the selected window, look at the\n\
+values of `same-window-buffer-names' and `same-window-regexps'.\n\
+Those variables take precedence over this one.");
Vspecial_display_regexps = Qnil;
DEFVAR_LISP ("special-display-function", &Vspecial_display_function,
"*Delete any window less than this wide.");
window_min_width = 10;
+ DEFVAR_BOOL ("scroll-preserve-screen-position",
+ &scroll_preserve_screen_position,
+ "*Nonzero means scroll commands move point to keep its screen line unchanged.");
+ scroll_preserve_screen_position = 0;
+
+ DEFVAR_LISP ("window-configuration-change-hook",
+ &Vwindow_configuration_change_hook,
+ "Functions to call when window configuration changes.\n\
+The selected frame is the one whose configuration has changed.");
+ Vwindow_configuration_change_hook = Qnil;
+
defsubr (&Sselected_window);
defsubr (&Sminibuffer_window);
defsubr (&Swindow_minibuffer_p);
defsubr (&Sdelete_window);
defsubr (&Sset_window_buffer);
defsubr (&Sselect_window);
+ defsubr (&Sspecial_display_p);
+ defsubr (&Ssame_window_p);
defsubr (&Sdisplay_buffer);
defsubr (&Ssplit_window);
defsubr (&Senlarge_window);
defsubr (&Sset_window_configuration);
defsubr (&Scurrent_window_configuration);
defsubr (&Ssave_window_excursion);
+ defsubr (&Scompare_window_configurations);
}
+void
keys_of_window ()
{
initial_define_key (control_x_map, '1', "delete-other-windows");
HCoop / bpt / emacs.git / blobdiff