p->fringes_outside_margins = Qnil;
p->scroll_bar_width = Qnil;
p->vertical_scroll_bar_type = Qt;
+ p->overlay_arrow_bitmap = 0;
Vwindow_list = Qnil;
return val;
}
DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1, 0,
- doc: /* Returns non-nil if WINDOW is a minibuffer window. */)
+ doc: /* Returns non-nil if WINDOW is a minibuffer window.
+WINDOW defaults to the selected window. */)
(window)
Lisp_Object window;
{
return XWINDOW (window);
}
+static struct window *
+decode_any_window (window)
+ register Lisp_Object window;
+{
+ if (NILP (window))
+ return XWINDOW (selected_window);
+
+ CHECK_WINDOW (window);
+ return XWINDOW (window);
+}
+
DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
doc: /* Return the buffer that WINDOW is displaying. */)
(window)
(window)
Lisp_Object window;
{
- return decode_window (window)->total_lines;
+ return decode_any_window (window)->total_lines;
}
DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0,
(window)
Lisp_Object window;
{
- return make_number (window_box_text_cols (decode_window (window)));
+ return make_number (window_box_text_cols (decode_any_window (window)));
}
DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
doc: /* Return a list of the edge coordinates of WINDOW.
\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
-RIGHT is one more than the rightmost column used by WINDOW,
-and BOTTOM is one more than the bottommost row used by WINDOW
- and its mode-line. */)
+RIGHT is one more than the rightmost column occupied by WINDOW,
+and BOTTOM is one more than the bottommost row occupied by WINDOW.
+The edges include the space used by the window's scroll bar,
+display margins, fringes, header line, and mode line, if it has them.
+To get the edges of the actual text area, use `window-inside-edges'. */)
(window)
Lisp_Object window;
{
- register struct window *w = decode_window (window);
+ register struct window *w = decode_any_window (window);
return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
Qnil))));
}
+DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
+ doc: /* Return a list of the edge pixel coordinates of WINDOW.
+\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
+RIGHT is one more than the rightmost x position occupied by WINDOW,
+and BOTTOM is one more than the bottommost y position occupied by WINDOW.
+The pixel edges include the space used by the window's scroll bar,
+display margins, fringes, header line, and mode line, if it has them.
+To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
+ (window)
+ Lisp_Object window;
+{
+ register struct window *w = decode_any_window (window);
+
+ return Fcons (make_number (WINDOW_LEFT_EDGE_X (w)),
+ Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),
+ Fcons (make_number (WINDOW_RIGHT_EDGE_X (w)),
+ Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w)),
+ Qnil))));
+}
+
+DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
+ doc: /* Return a list of the edge coordinates of WINDOW.
+\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
+RIGHT is one more than the rightmost column used by text in WINDOW,
+and BOTTOM is one more than the bottommost row used by text in WINDOW.
+The inside edges do not include the space used by the window's scroll bar,
+display margins, fringes, header line, and/or mode line. */)
+ (window)
+ Lisp_Object window;
+{
+ register struct window *w = decode_any_window (window);
+
+ return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
+ + WINDOW_LEFT_MARGIN_COLS (w)
+ + WINDOW_LEFT_FRINGE_COLS (w)),
+ make_number (WINDOW_TOP_EDGE_LINE (w)
+ + WINDOW_HEADER_LINE_LINES (w)),
+ make_number (WINDOW_RIGHT_EDGE_COL (w)
+ - WINDOW_RIGHT_MARGIN_COLS (w)
+ - WINDOW_RIGHT_FRINGE_COLS (w)),
+ make_number (WINDOW_BOTTOM_EDGE_LINE (w)
+ - WINDOW_MODE_LINE_LINES (w)));
+}
+
+DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
+ doc: /* Return a list of the edge coordinates of WINDOW.
+\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
+RIGHT is one more than the rightmost x position used by text in WINDOW,
+and BOTTOM is one more than the bottommost y position used by text in WINDOW.
+The inside edges do not include the space used by the window's scroll bar,
+display margins, fringes, header line, and/or mode line. */)
+ (window)
+ Lisp_Object window;
+{
+ register struct window *w = decode_any_window (window);
+
+ return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
+ + WINDOW_LEFT_MARGIN_WIDTH (w)
+ + WINDOW_LEFT_FRINGE_WIDTH (w)),
+ make_number (WINDOW_TOP_EDGE_Y (w)
+ + WINDOW_HEADER_LINE_HEIGHT (w)),
+ make_number (WINDOW_RIGHT_EDGE_X (w)
+ - WINDOW_RIGHT_MARGIN_WIDTH (w)
+ - WINDOW_RIGHT_FRINGE_WIDTH (w)),
+ make_number (WINDOW_BOTTOM_EDGE_Y (w)
+ - WINDOW_MODE_LINE_HEIGHT (w)));
+}
+
/* Test if the character at column *X, row *Y is within window W.
If it is not, return ON_NOTHING;
if it is in the window's text area,
scroll bars. */
if (WINDOW_WANTS_MODELINE_P (w)
- && *y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w)
- && *y < bottom_y)
+ && *y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w))
{
part = ON_MODE_LINE;
return ON_VERTICAL_BORDER;
}
+ /* Convert X and Y to window relative coordinates.
+ Mode line starts at left edge of window. */
+ *x -= x0;
+ *y -= top_y;
return part;
}
if (WINDOW_WANTS_HEADER_LINE_P (w)
- && *y >= top_y
&& *y < top_y + CURRENT_HEADER_LINE_HEIGHT (w))
{
part = ON_HEADER_LINE;
&& (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? (*x >= left_x + WINDOW_LEFT_FRINGE_WIDTH (w))
: (*x < left_x + lmargin_width)))
- return ON_LEFT_MARGIN;
+ {
+ *x -= left_x;
+ if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
+ *x -= WINDOW_LEFT_FRINGE_WIDTH (w);
+ *y -= top_y;
+ return ON_LEFT_MARGIN;
+ }
/* Convert X and Y to window-relative pixel coordinates. */
*x -= left_x;
&& (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? (*x < right_x - WINDOW_RIGHT_FRINGE_WIDTH (w))
: (*x >= right_x - rmargin_width)))
- return ON_RIGHT_MARGIN;
+ {
+ *x -= right_x;
+ if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
+ *x -= WINDOW_RIGHT_FRINGE_WIDTH (w);
+ *y -= top_y;
+ return ON_RIGHT_MARGIN;
+ }
/* Convert X and Y to window-relative pixel coordinates. */
*x -= left_x + WINDOW_LEFT_FRINGE_WIDTH (w);
int x, y;
Lisp_Object lx, ly;
- CHECK_LIVE_WINDOW (window);
+ CHECK_WINDOW (window);
w = XWINDOW (window);
f = XFRAME (w->frame);
CHECK_CONS (coordinates);
{
register struct window *w = decode_window (window);
- if (NILP (arg))
- w->dedicated = Qnil;
- else
- w->dedicated = Qt;
+ w->dedicated = arg;
return w->dedicated;
}
if (!NILP (tem))
{
unshow_buffer (p);
- unchain_marker (p->pointm);
- unchain_marker (p->start);
+ unchain_marker (XMARKER (p->pointm));
+ unchain_marker (XMARKER (p->start));
}
/* Free window glyph matrices. It is sure that they are allocated
DELETE_BUFFER_WINDOWS, /* Arg is buffer */
GET_LARGEST_WINDOW,
UNSHOW_BUFFER, /* Arg is buffer */
+ REDISPLAY_BUFFER_WINDOWS, /* Arg is buffer */
CHECK_ALL_WINDOWS
};
}
break;
+ case REDISPLAY_BUFFER_WINDOWS:
+ if (EQ (w->buffer, obj))
+ {
+ mark_window_display_accurate (window, 0);
+ w->update_mode_line = Qt;
+ XBUFFER (obj)->prevent_redisplay_optimizations_p = 1;
+ ++update_mode_lines;
+ best_window = window;
+ }
+ break;
+
/* Check for a window that has a killed buffer. */
case CHECK_ALL_WINDOWS:
if (! NILP (w->buffer)
DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0,
doc: /* Return the window least recently selected or used for display.
+Return a full-width window if possible.
If optional argument FRAME is `visible', search all visible frames.
If FRAME is 0, search all visible and iconified frames.
If FRAME is t, search all frames.
return 1;
}
+/* Calculate new sizes for windows in the list FORWARD when the window size
+ goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
+ The number of windows in FORWARD is NCHILDREN, and the number that
+ can shrink is SHRINKABLE.
+ The minimum size a window can have is MIN_SIZE.
+ If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
+ If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
+ shrinking rows.
+
+ This function returns an allocated array of new sizes that the caller
+ must free. The size -1 means the window is fixed and RESIZE_FIXED_P
+ is zero. Array index 0 refers to the first window in FORWARD, 1 to
+ the second, and so on.
+
+ This function tries to keep windows at least at the minimum size
+ and resize other windows before it resizes any window to zero (i.e.
+ delete that window).
+
+ Windows are resized proportional to their size, so bigger windows
+ shrink more than smaller windows. */
+static int *
+shrink_windows (total, size, nchildren, shrinkable,
+ min_size, resize_fixed_p, forward, width_p)
+ int total, size, nchildren, shrinkable, min_size;
+ int resize_fixed_p, width_p;
+ Lisp_Object forward;
+{
+ int available_resize = 0;
+ int *new_sizes;
+ struct window *c;
+ Lisp_Object child;
+ int smallest = total;
+ int total_removed = 0;
+ int total_shrink = total - size;
+ int i;
+
+ new_sizes = xmalloc (sizeof (*new_sizes) * nchildren);
+
+ for (i = 0, child = forward; !NILP (child); child = c->next, ++i)
+ {
+ int child_size;
+
+ c = XWINDOW (child);
+ child_size = width_p ? XINT (c->total_cols) : XINT (c->total_lines);
+
+ if (! resize_fixed_p && window_fixed_size_p (c, width_p, 0))
+ new_sizes[i] = -1;
+ else
+ {
+ new_sizes[i] = child_size;
+ if (child_size > min_size)
+ available_resize += child_size - min_size;
+ }
+ }
+ /* We might need to shrink some windows to zero. Find the smallest
+ windows and set them to 0 until we can fulfil the new size. */
+
+ while (shrinkable > 1 && size + available_resize < total)
+ {
+ for (i = 0; i < nchildren; ++i)
+ if (new_sizes[i] > 0 && smallest > new_sizes[i])
+ smallest = new_sizes[i];
+
+ for (i = 0; i < nchildren; ++i)
+ if (new_sizes[i] == smallest)
+ {
+ /* Resize this window down to zero. */
+ new_sizes[i] = 0;
+ if (smallest > min_size)
+ available_resize -= smallest - min_size;
+ available_resize += smallest;
+ --shrinkable;
+ total_removed += smallest;
+
+ /* Out of for, just remove one window at the time and
+ check again if we have enough space. */
+ break;
+ }
+ }
+
+ /* Now, calculate the new sizes. Try to shrink each window
+ proportional to its size. */
+ for (i = 0; i < nchildren; ++i)
+ {
+ if (new_sizes[i] > min_size)
+ {
+ int to_shrink = total_shrink*new_sizes[i]/total;
+ if (new_sizes[i] - to_shrink < min_size)
+ to_shrink = new_sizes[i] - min_size;
+ new_sizes[i] -= to_shrink;
+ total_removed += to_shrink;
+ }
+ }
+
+ /* Any reminder due to rounding, we just subtract from windows
+ that are left and still can be shrunk. */
+ while (total_shrink > total_removed)
+ {
+ for (i = 0; i < nchildren; ++i)
+ if (new_sizes[i] > min_size)
+ {
+ --new_sizes[i];
+ ++total_removed;
+
+ /* Out of for, just shrink one window at the time and
+ check again if we have enough space. */
+ break;
+ }
+ }
+
+ return new_sizes;
+}
/* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
WINDOW's width. Resize WINDOW's children, if any, so that they
int fixed_size, each, extra, n;
int resize_fixed_p, nfixed;
int last_pos, first_pos, nchildren, total;
+ int *new_sizes = NULL;
/* Determine the fixed-size portion of the this window, and the
number of child windows. */
windows. */
resize_fixed_p = nfixed == nchildren || size < fixed_size;
- /* Compute how many lines/columns to add to each child. The
+ /* Compute how many lines/columns to add/remove to each child. The
value of extra takes care of rounding errors. */
n = resize_fixed_p ? nchildren : nchildren - nfixed;
- each = (size - total) / n;
- extra = (size - total) - n * each;
+ if (size < total && n > 1)
+ new_sizes = shrink_windows (total, size, nchildren, n, min_size,
+ resize_fixed_p, *forward, width_p);
+ else
+ {
+ each = (size - total) / n;
+ extra = (size - total) - n * each;
+ }
/* Compute new children heights and edge positions. */
first_pos = width_p ? XINT (w->left_col) : XINT (w->top_line);
last_pos = first_pos;
- for (child = *forward; !NILP (child); child = c->next)
+ for (n = 0, child = *forward; !NILP (child); child = c->next, ++n)
{
int new_size, old_size;
/* If this child can be resized, do it. */
if (resize_fixed_p || !window_fixed_size_p (c, width_p, 0))
{
- new_size = old_size + each + extra;
+ new_size = new_sizes ? new_sizes[n] : old_size + each + extra;
extra = 0;
}
/* 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_size;
}
+ if (new_sizes) xfree (new_sizes);
+
/* We should have covered the parent exactly with child windows. */
xassert (size == last_pos - first_pos);
return Qnil;
}
+EXFUN (Fset_window_fringes, 4);
+EXFUN (Fset_window_scroll_bars, 4);
/* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
means it's allowed to run hooks. See make_frame for a case where
/* This may call adjust_window_margins three times, so
temporarily disable window margins. */
+ Lisp_Object save_left = w->left_margin_cols;
+ Lisp_Object save_right = w->right_margin_cols;
+
w->left_margin_cols = w->right_margin_cols = Qnil;
Fset_window_fringes (window,
b->scroll_bar_width,
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);
}
the default is to reset these from BUFFER's local settings or the frame
defaults. */)
(window, buffer, keep_margins)
- register Lisp_Object window, buffer;
+ register Lisp_Object window, buffer, keep_margins;
{
register Lisp_Object tem;
register struct window *w = decode_window (window);
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, also make WINDOW's buffer current.
FRAME_SAMPLE_VISIBILITY (f);
- if (!EQ (frame, selected_frame))
+ if (EQ (frame, selected_frame))
+ ; /* Assume the selected frame is already visible enough. */
+ else if (minibuf_level > 0
+ && MINI_WINDOW_P (XWINDOW (selected_window))
+ && WINDOW_LIVE_P (minibuf_selected_window)
+ && EQ (frame, WINDOW_FRAME (XWINDOW (minibuf_selected_window))))
+ ; /* Assume the frame from which we invoked the minibuffer is visible. */
+ else
{
if (FRAME_ICONIFIED_P (f))
Fmake_frame_visible (frame);
If `display-buffer-reuse-frames' is non-nil, and another frame is currently
displaying BUFFER, then simply raise that frame.
-The variables `special-display-buffer-names', `special-display-regexps',
-`same-window-buffer-names', and `same-window-regexps' customize how certain
-buffer names are handled.
+The variables `special-display-buffer-names',
+`special-display-regexps', `same-window-buffer-names', and
+`same-window-regexps' customize how certain buffer names are handled.
+The latter two take effect only if NOT-THIS-WINDOW is t.
If optional argument FRAME is `visible', search all visible frames.
If FRAME is 0, search all visible and iconified frames.
return display_buffer_1 (window);
}
+
+DEFUN ("force-window-update", Fforce_window_update, Sforce_window_update,
+ 0, 1, 0,
+ doc: /* Force redisplay of all windows.
+If optional arg OBJECT is a window, force redisplay of that window only.
+If OBJECT is a buffer or buffer name, force redisplay of all windows
+displaying that buffer. */)
+ (object)
+ Lisp_Object object;
+{
+ if (NILP (object))
+ {
+ windows_or_buffers_changed++;
+ update_mode_lines++;
+ return Qt;
+ }
+
+ if (WINDOWP (object))
+ {
+ struct window *w = XWINDOW (object);
+ mark_window_display_accurate (object, 0);
+ w->update_mode_line = Qt;
+ if (BUFFERP (w->buffer))
+ XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+ ++update_mode_lines;
+ return Qt;
+ }
+
+ if (STRINGP (object))
+ object = Fget_buffer (object);
+ if (BUFFERP (object) && !NILP (XBUFFER (object)->name))
+ {
+ /* Walk all windows looking for buffer, and force update
+ of each of those windows. */
+
+ object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, 0, Qvisible);
+ return NILP (object) ? Qnil : Qt;
+ }
+
+ /* If nothing suitable was found, just return.
+ We could signal an error, but this feature will typically be used
+ asynchronously in timers or process sentinels, so we don't. */
+ return Qnil;
+}
+
+
void
temp_output_buffer_show (buf)
register Lisp_Object buf;
w = XWINDOW (window);
XSETFASTINT (w->hscroll, 0);
XSETFASTINT (w->min_hscroll, 0);
- set_marker_restricted_both (w->start, buf, 1, 1);
- set_marker_restricted_both (w->pointm, buf, 1, 1);
+ set_marker_restricted_both (w->start, buf, BEG, BEG);
+ set_marker_restricted_both (w->pointm, buf, BEG, BEG);
/* Run temp-buffer-show-hook, with the chosen window selected
and its buffer current. */
- if (!NILP (Vrun_hooks))
+
+ if (!NILP (Vrun_hooks)
+ && !NILP (Fboundp (Qtemp_buffer_show_hook))
+ && !NILP (Fsymbol_value (Qtemp_buffer_show_hook)))
{
- Lisp_Object tem;
- tem = Fboundp (Qtemp_buffer_show_hook);
- if (!NILP (tem))
- {
- tem = Fsymbol_value (Qtemp_buffer_show_hook);
- if (!NILP (tem))
- {
- 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);
+ call1 (Vrun_hooks, Qtemp_buffer_show_hook);
+ unbind_to (count, Qnil);
}
}
}
{
if (minibuf_level > 0
&& MINI_WINDOW_P (XWINDOW (selected_window))
- && !NILP (minibuf_selected_window)
&& WINDOW_LIVE_P (minibuf_selected_window))
return minibuf_selected_window;
DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
2, 3, 0,
doc: /* Set width of marginal areas of window WINDOW.
-If window is nil, set margins of the currently selected window.
-First parameter LEFT-WIDTH specifies the number of character
-cells to reserve for the left marginal area. Second parameter
-RIGHT-WIDTH does the same for the right marginal area.
-A nil width parameter means no margin. */)
+If WINDOW is nil, set margins of the currently selected window.
+Second arg LEFT-WIDTH specifies the number of character cells to
+reserve for the left marginal area. Optional third arg RIGHT-WIDTH
+does the same for the right marginal area. A nil width parameter
+means no margin. */)
(window, left, right)
Lisp_Object window, left, right;
{
struct window *w = decode_window (window);
- /* TODO: It doesn't make sense to use FLOATs here, since
- the rest of the code assumes they are integers.
- So don't allow floats! ++KFS */
+ /* Translate negative or zero widths to nil.
+ Margins that are too wide have to be checked elsewhere. */
if (!NILP (left))
- CHECK_NUMBER_OR_FLOAT (left);
- if (!NILP (right))
- CHECK_NUMBER_OR_FLOAT (right);
+ {
+ CHECK_NUMBER (left);
+ if (XINT (left) <= 0)
+ left = Qnil;
+ }
- /* Check widths < 0 and translate a zero width to nil.
- Margins that are too wide have to be checked elsewhere. */
- if ((INTEGERP (left) && XINT (left) < 0)
- || (FLOATP (left) && XFLOAT_DATA (left) <= 0))
- XSETFASTINT (left, 0);
- if (INTEGERP (left) && XFASTINT (left) == 0)
- left = Qnil;
-
- if ((INTEGERP (right) && XINT (right) < 0)
- || (FLOATP (right) && XFLOAT_DATA (right) <= 0))
- XSETFASTINT (right, 0);
- if (INTEGERP (right) && XFASTINT (right) == 0)
- right = Qnil;
+ if (!NILP (right))
+ {
+ CHECK_NUMBER (right);
+ if (XINT (right) <= 0)
+ right = Qnil;
+ }
if (!EQ (w->left_margin_cols, left)
|| !EQ (w->right_margin_cols, right))
DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
2, 4, 0,
- doc: /* Set width of fringes of window WINDOW.
-
-If window is nil, set fringes of the currently selected window.
-Second parameter LEFT-WIDTH specifies the number of pixels to reserve
-for the left fringe. Third parameter RIGHT-WIDTH does the same for
-the right fringe. Fourth parameter OUTSIDE-MARGINS non-nil specifies
-that fringes are drawn outside of the display margins; by default, fringes
-are drawn between display marginal areas and the text area.
-A nil width parameter means to use the frame's corresponding fringe width. */)
+ doc: /* Set the fringe widths of window WINDOW.
+If WINDOW is nil, set the fringe widths of the currently selected
+window.
+Second arg LEFT-WIDTH specifies the number of pixels to reserve for
+the left fringe. Optional third arg RIGHT-WIDTH specifies the right
+fringe width. If a fringe width arg is nil, that means to use the
+frame's default fringe width. Default fringe widths can be set with
+the command `set-fringe-style'.
+If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
+outside of the display margins. By default, fringes are drawn between
+display marginal areas and the text area. */)
(window, left, right, outside_margins)
Lisp_Object window, left, right, outside_margins;
{
0, 1, 0,
doc: /* Get width of fringes of window WINDOW.
If WINDOW is omitted or nil, use the currently selected window.
-Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).
-If a window specific fringe width is not set, its width will be returned
-as nil. */)
+Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
(window)
Lisp_Object window;
{
this is automatically adjusted to a multiple of the frame column width.
Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
bar: left, right, or nil.
-A width of nil and type of t means to use the frame's corresponding value. */)
+If WIDTH is nil, use the frame's scroll-bar width.
+If TYPE is t, use the frame's scroll-bar type. */)
(window, width, vertical_type, horizontal_type)
Lisp_Object window, width, vertical_type, horizontal_type;
{
if (XINT (width) == 0)
vertical_type = Qnil;
+ if (!(EQ (vertical_type, Qnil)
+ || EQ (vertical_type, Qleft)
+ || EQ (vertical_type, Qright)
+ || EQ (vertical_type, Qt)))
+ error ("Invalid type of vertical scroll bar");
+
if (!EQ (w->scroll_bar_width, width)
|| !EQ (w->vertical_scroll_bar_type, vertical_type))
{
0, 1, 0,
doc: /* Get width and type of scroll bars of window WINDOW.
If WINDOW is omitted or nil, use the currently selected window.
-Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE). */)
+Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
+If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
+value. */)
(window)
Lisp_Object window;
{
followed by OTHER-ARGS--it can display BUFFER in any way it likes.
All this is done by the function found in `special-display-function'.
+If the specified frame parameters include (same-buffer . t), the
+buffer is displayed in the currently selected window. Otherwise, if
+they include (same-frame . t), the buffer is displayed in a new window
+in the currently selected frame.
+
If this variable appears \"not to work\", because you add a name to it
but that buffer still appears in the selected window, look at the
values of `same-window-buffer-names' and `same-window-regexps'.
followed by OTHER-ARGS--it can display the buffer in any way it likes.
All this is done by the function found in `special-display-function'.
+If the specified frame parameters include (same-buffer . t), the
+buffer is displayed in the currently selected window. Otherwise, if
+they include (same-frame . t), the buffer is displayed in a new window
+in the currently selected frame.
+
If this variable appears \"not to work\", because you add a regexp to it
but the matching buffers still appear in the selected window, look at the
values of `same-window-buffer-names' and `same-window-regexps'.
defsubr (&Swindow_redisplay_end_trigger);
defsubr (&Sset_window_redisplay_end_trigger);
defsubr (&Swindow_edges);
+ defsubr (&Swindow_pixel_edges);
+ defsubr (&Swindow_inside_edges);
+ defsubr (&Swindow_inside_pixel_edges);
defsubr (&Scoordinates_in_window_p);
defsubr (&Swindow_at);
defsubr (&Swindow_point);
defsubr (&Sspecial_display_p);
defsubr (&Ssame_window_p);
defsubr (&Sdisplay_buffer);
+ defsubr (&Sforce_window_update);
defsubr (&Ssplit_window);
defsubr (&Senlarge_window);
defsubr (&Sshrink_window);
initial_define_key (global_map, Ctl('L'), "recenter");
initial_define_key (meta_map, 'r', "move-to-window-line");
}
+
+/* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
+ (do not change this comment) */