* window.h (window): Rename slot "nest" to "combination_limit".
* window.c (Fwindow_nest): Rename to Fwindow_combination_limit.
(Fset_window_nest): Rename to Fset_window_combination_limit.
(Vwindow_nest): Rename to Vwindow_combination_limit.
(recombine_windows, make_parent_window, make_window)
(Fsplit_window_internal, saved_window)
(Fset_window_configuration, save_window_save): Rename all
occurrences of window_nest to window_combination_limit.
* window.el (split-window, window-state-get-1)
(window-state-put-1, window-state-put-2): Rename occurrences of
window-nest to window-combination-limit.
* cus-start.el (window-nest): Rename to
window-combination-limit.
* windows.texi (Resizing Windows, Splitting Windows): Rename
occurrences of window-nest to window-combination-limit.
+2011-11-16 Martin Rudalics <rudalics@gmx.at>
+
+ * windows.texi (Resizing Windows, Splitting Windows): Rename
+ occurrences of window-nest to window-combination-limit.
+
2011-11-14 Juanma Barranquero <lekktu@gmail.com>
* intro.texi (Lisp History): Fix typo.
The optional argument @var{ignore} has the same meaning as for the
function @code{window-resizable} above.
-The choice of which window edge this function alters depends on the
-splitting and nesting status of the involved windows; in some cases,
-it may alter both edges. @xref{Splitting Windows}. To resize by
-moving only the bottom or right edge of a window, use the function
-@code{adjust-window-trailing-edge}, below.
+The choice of which window edges this function alters depends on the
+values of the option @code{window-splits} and the combination-limit
+status of the involved windows; in some cases, it may alter both edges.
+@xref{Splitting Windows}. To resize by moving only the bottom or right
+edge of a window, use the function @code{adjust-window-trailing-edge},
+below.
@end defun
@c The commands enlarge-window, enlarge-window-horizontally,
deleting @var{window} will usually affect @emph{all} windows in
@var{window}'s combination.
-The setting of this variable has no effect if @code{window-nest} (see
-below) is non-@code{nil}.
+The setting of this variable has no effect if
+@code{window-combination-limit} (see below) is non-@code{nil}.
@end defopt
To illustrate the use of @code{window-splits} consider the following
@end group
@end smallexample
-@defopt window-nest
+@defopt window-combination-limit
If this variable is @code{nil}, @code{split-window} creates a new parent
window if and only if the old window has no parent window or shall be
split orthogonally to the combination it is part of. If this variable
-is non-@code{nil}, @code{split-window} always creates a new parent
-window. If this variable is always non-@code{nil}, a frame's window
-tree is a binary tree so every window but the frame's root window has
-exactly one sibling.
-
-The value of this variable is also assigned to the nest status of the
-new parent window. The nest status of any window can be retrieved via
-the function @code{window-nest} and altered by the function
-@code{set-window-nest}, see below.
+is @code{t}, @code{split-window} always creates a new parent window. If
+this variable is always @code{t}, a frame's window tree is a binary tree
+so every window but the frame's root window has exactly one sibling.
+Other values are reserved for future use.
+
+The value of this variable is also assigned to the combination-limit
+status of the new parent window. The combination-limit status of any
+window can be retrieved via the function @code{window-combination-limit}
+and altered by the function @code{set-window-combination-limit}, see
+below.
@end defopt
-@defun window-nest &optional window
-This function returns the nest status of @var{window}. The argument
-@var{window} can be any window and defaults to the selected one. Note,
-however, that the nest status is currently meaningful for internal
-windows only.
-
-@cindex nest status
-The @dfn{nest status} of a window specifies whether that window may be
-removed and its child windows recombined with that window's siblings
-when such a sibling's child window is deleted. The nest status is
-initially assigned by @code{split-window} from the current value of the
-variable @code{window-nest} (see above) and can be reset by the function
-@code{set-window-nest} (see below).
+@defun window-combination-limit &optional window
+This function returns the combination-limit status of @var{window}. The
+argument @var{window} can be any window and defaults to the selected
+one. Note, however, that the combination-limit status is currently
+meaningful for internal windows only.
+
+@cindex combination-limit status
+The @dfn{combination-limit status} of a window specifies whether that
+window may be removed and its child windows recombined with that
+window's siblings when such a sibling's child window is deleted. The
+combination-limit status is initially assigned by @code{split-window}
+from the current value of the variable @code{window-combination-limit}
+(see above) and can be reset by the function
+@code{set-window-combination-limit} (see below).
If the return value is @code{nil}, child windows of @var{window} may be
recombined with @var{window}'s siblings when a window gets deleted. A
never (re-)combined with @var{window}'s siblings in such a case.
@end defun
-@defun set-window-nest window &optional status
-This functions sets the nest status (see above) of @var{window} to
-@var{status}. The argument @var{window} can be any window and defaults
-to the selected one. Note that setting the nest status is meaningful
-for internal windows only. The return value is @var{status}.
+@defun set-window-combination-limit window &optional status
+This functions sets the combination-limit status (see above) of
+@var{window} to @var{status}. The argument @var{window} can be any
+window and defaults to the selected one. Note that setting the
+combination-limit status is meaningful for internal windows only. The
+return value is @var{status}.
@end defun
-To illustrate the use of @code{window-nest} consider the following
-configuration (throughout the following examples we shall assume that
-@code{window-splits} invariantly is @code{nil}).
+To illustrate the use of @code{window-combination-limit} consider the
+following configuration (throughout the following examples we shall
+assume that @code{window-splits} invariantly is @code{nil}).
@smallexample
@group
______________________________________
@end smallexample
Splitting @code{W2} into two windows above each other with
-@code{window-nest} equal @code{nil} will get you a configuration like:
+@code{window-combination-limit} equal @code{nil} will get you a
+configuration like:
@smallexample
@group
______________________________________
Hence, with respect to the initial configuration, window @code{W2} has
grown at the expense of window @code{W3}. If, however, in the initial
-configuration you had split @code{W2} with @code{window-nest} bound to
-@code{t}, a new internal window @code{W5} would have been created as
-depicted below.
+configuration you had split @code{W2} with
+@code{window-combination-limit} bound to @code{t}, a new internal window
+@code{W5} would have been created as depicted below.
@smallexample
@group
______________________________________
+2011-11-16 Martin Rudalics <rudalics@gmx.at>
+
+ * window.el (split-window, window-state-get-1)
+ (window-state-put-1, window-state-put-2): Rename occurrences of
+ window-nest to window-combination-limit.
+ * cus-start.el (window-nest): Rename to
+ window-combination-limit.
+
2011-11-16 Chong Yidong <cyd@gnu.org>
* progmodes/autoconf.el (autoconf-mode): Fix comment-start-skip
(const :tag "Only on ttys" :value tty)
(other :tag "Always" t)) "23.1")
(window-splits windows boolean "24.1")
- (window-nest windows boolean "24.1")
+ (window-combination-limit windows boolean "24.1")
;; xdisp.c
(show-trailing-whitespace whitespace-faces boolean nil
:safe booleanp)
(parent (window-parent window))
(function (window-parameter window 'split-window))
(window-side (window-parameter window 'window-side))
- ;; Rebind `window-nest' since in some cases we may have to
- ;; override its value.
- (window-nest window-nest)
+ ;; Rebind `window-combination-limit' since in some cases we may
+ ;; have to override its value.
+ (window-combination-limit window-combination-limit)
atom-root)
(window--check frame)
(or (not parent)
(not (window-parameter parent 'window-side))))
;; WINDOW is a side root window. To make sure that a new parent
- ;; window gets created set `window-nest' to t.
- (setq window-nest t))
+ ;; window gets created set `window-combination-limit' to t.
+ (setq window-combination-limit t))
(when (and window-splits size (> size 0))
;; If `window-splits' is non-nil and SIZE is a non-negative
;; integer, we cannot reasonably resize other windows. Rather
- ;; bind `window-nest' to t to make sure that subsequent window
- ;; deletions are handled correctly.
- (setq window-nest t))
+ ;; bind `window-combination-limit' to t to make sure that
+ ;; subsequent window deletions are handled correctly.
+ (setq window-combination-limit t))
(let* ((parent-size
;; `parent-size' is the size of WINDOW's parent, provided
;; `resize' non-nil means we are supposed to resize other
;; windows in WINDOW's combination.
(resize
- (and window-splits (not window-nest)
+ (and window-splits (not window-combination-limit)
;; Resize makes sense in iso-combinations only.
(window-combined-p window horizontal)))
;; `old-size' is the current size of WINDOW.
;; Make new-parent non-nil if we need a new parent window;
;; either because we want to nest or because WINDOW is not
;; iso-combined.
- (or window-nest (not (window-combined-p window horizontal))))
+ (or window-combination-limit
+ (not (window-combined-p window horizontal))))
(setq new-normal
;; Make new-normal the normal size of the new window.
(cond
(total-width . ,(window-total-size window t))
(normal-height . ,(window-normal-size window))
(normal-width . ,(window-normal-size window t))
- (nest . ,(window-nest window))
+ (combination-limit . ,(window-combination-limit window))
,@(let (list)
(dolist (parameter (window-parameters window))
(unless (memq (car parameter)
window-safe-min-width)))
(if (window-sizable-p window (- size) horizontal 'safe)
- (let* ((window-nest (assq 'nest item)))
- ;; We must inherit the nesting, otherwise we might mess
- ;; up handling of atomic and side window.
+ (let* ((window-combination-limit
+ (assq 'combination-limit item)))
+ ;; We must inherit the combiantion limit, otherwise
+ ;; we might mess up handling of atomic and side
+ ;; window.
(setq new (split-window window size horizontal)))
;; Give up if we can't resize window down to safe sizes.
(error "Cannot resize window %s" window))
(dolist (item window-state-put-list)
(let ((window (car item))
(splits (cdr (assq 'splits item)))
- (nest (cdr (assq 'nest item)))
+ (combination-limit (cdr (assq 'combination-limit item)))
(parameters (cdr (assq 'parameters item)))
(state (cdr (assq 'buffer item))))
- (when nest (set-window-nest window nest))
+ (when combination-limit
+ (set-window-combination-limit window combination-limit))
;; Process parameters.
(when parameters
(dolist (parameter parameters)
+2011-11-16 Martin Rudalics <rudalics@gmx.at>
+
+ * window.h (window): Rename slot "nest" to "combination_limit".
+ * window.c (Fwindow_nest): Rename to Fwindow_combination_limit.
+ (Fset_window_nest): Rename to Fset_window_combination_limit.
+ (Vwindow_nest): Rename to Vwindow_combination_limit.
+ (recombine_windows, make_parent_window, make_window)
+ (Fsplit_window_internal, saved_window)
+ (Fset_window_configuration, save_window_save): Rename all
+ occurrences of window_nest to window_combination_limit.
+
2011-11-15 Juanma Barranquero <lekktu@gmail.com>
* image.c (imagemagick_load_image): Fix typo.
return decode_any_window (window)->prev;
}
-DEFUN ("window-nest", Fwindow_nest, Swindow_nest, 0, 1, 0,
- doc: /* Return nest status of window WINDOW.
+DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 0, 1, 0,
+ doc: /* Return combination limit of window WINDOW.
If WINDOW is omitted or nil, it defaults to the selected window.
If the return value is nil, child windows of WINDOW can be recombined with
-WINDOW's siblings. A return value of non-nil means that child windows of
+WINDOW's siblings. A return value of t means that child windows of
WINDOW are never \(re-)combined with WINDOW's siblings. */)
(Lisp_Object window)
{
- return decode_any_window (window)->nest;
+ return decode_any_window (window)->combination_limit;
}
-DEFUN ("set-window-nest", Fset_window_nest, Sset_window_nest, 2, 2, 0,
- doc: /* Set nest status of window WINDOW to STATUS; return STATUS.
+DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
+ doc: /* Set combination limit of window WINDOW to STATUS; return STATUS.
If WINDOW is omitted or nil, it defaults to the selected window.
-If STATUS is nil, child windows of WINDOW can be recombined with WINDOW's
-siblings. STATUS non-nil means that child windows of WINDOW are never
-\(re-)combined with WINDOW's siblings. */)
+If STATUS is nil, child windows of WINDOW can be recombined with
+WINDOW's siblings. STATUS t means that child windows of WINDOW are
+never \(re-)combined with WINDOW's siblings. Other values are reserved
+for future use. */)
(Lisp_Object window, Lisp_Object status)
{
register struct window *w = decode_any_window (window);
- w->nest = status;
+ w->combination_limit = status;
- return w->nest;
+ return w->combination_limit;
}
DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
w = XWINDOW (window);
parent = w->parent;
- if (!NILP (parent) && NILP (w->nest))
+ if (!NILP (parent) && NILP (w->combination_limit))
{
p = XWINDOW (parent);
if (((!NILP (p->vchild) && !NILP (w->vchild))
p->start = Qnil;
p->pointm = Qnil;
p->buffer = Qnil;
- p->nest = Qnil;
+ p->combination_limit = Qnil;
p->window_parameters = Qnil;
}
w->start_at_line_beg = w->display_table = w->dedicated = Qnil;
w->base_line_number = w->base_line_pos = w->region_showing = Qnil;
w->column_number_displayed = w->redisplay_end_trigger = Qnil;
- w->nest = w->window_parameters = Qnil;
+ w->combination_limit = w->window_parameters = Qnil;
w->prev_buffers = w->next_buffers = Qnil;
/* Initialize non-Lisp data. */
w->desired_matrix = w->current_matrix = 0;
int horflag
/* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
= EQ (side, Qt) || EQ (side, Qleft) || EQ (side, Qright);
- int do_nest = 0;
+ int combination_limit = 0;
CHECK_WINDOW (old);
o = XWINDOW (old);
CHECK_NUMBER (total_size);
- /* Set do_nest to 1 if we have to make a new parent window. We do
- that if either `window-nest' is non-nil, or OLD has no parent, or
- OLD is ortho-combined. */
- do_nest =
- !NILP (Vwindow_nest)
+ /* Set combination_limit to 1 if we have to make a new parent window.
+ We do that if either `window-combination-limit' is t, or OLD has no
+ parent, or OLD is ortho-combined. */
+ combination_limit =
+ !NILP (Vwindow_combination_limit)
|| NILP (o->parent)
|| NILP (horflag
? (XWINDOW (o->parent)->hchild)
error ("Attempt to split minibuffer window");
else if (XINT (total_size) < (horflag ? 2 : 1))
error ("Size of new window too small (after split)");
- else if (!do_nest && !NILP (Vwindow_splits))
+ else if (!combination_limit && !NILP (Vwindow_splits))
/* `window-splits' non-nil means try to resize OLD's siblings
proportionally. */
{
}
/* This is our point of no return. */
- if (do_nest)
+ if (combination_limit)
{
/* Save the old value of o->normal_cols/lines. It gets corrupted
by make_parent_window and we need it below for assigning it to
make_parent_window (old, horflag);
p = XWINDOW (o->parent);
- /* Store value of `window-nest' in new parent's nest slot. */
- p->nest = Vwindow_nest;
+ /* Store value of `window-combination-limit' in new parent's
+ combination_limit slot. */
+ p->combination_limit = Vwindow_combination_limit;
/* These get applied below. */
p->new_total = horflag ? o->total_cols : o->total_lines;
p->new_normal = new_normal;
/* Put SIBLING into PARENT's place. */
replace_window (parent, sibling, 0);
/* Have SIBLING inherit the following three slot values from
- PARENT (the nest slot is not inherited). */
+ PARENT (the combination_limit slot is not inherited). */
s->normal_cols = p->normal_cols;
s->normal_lines = p->normal_lines;
/* Mark PARENT as deleted. */
Lisp_Object left_margin_cols, right_margin_cols;
Lisp_Object left_fringe_width, right_fringe_width, fringes_outside_margins;
Lisp_Object scroll_bar_width, vertical_scroll_bar_type, dedicated;
- Lisp_Object nest, window_parameters;
+ Lisp_Object combination_limit, window_parameters;
};
#define SAVED_WINDOW_N(swv,n) \
w->scroll_bar_width = p->scroll_bar_width;
w->vertical_scroll_bar_type = p->vertical_scroll_bar_type;
w->dedicated = p->dedicated;
- w->nest = p->nest;
+ w->combination_limit = p->combination_limit;
w->window_parameters = p->window_parameters;
XSETFASTINT (w->last_modified, 0);
XSETFASTINT (w->last_overlay_modified, 0);
p->scroll_bar_width = w->scroll_bar_width;
p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
p->dedicated = w->dedicated;
- p->nest = w->nest;
+ p->combination_limit = w->combination_limit;
p->window_parameters = w->window_parameters;
if (!NILP (w->buffer))
{
and the like.
This ignores a couple of things like the dedicatedness status of
- window, nest and the like. This might have to be fixed. */
+ window, combination_limit and the like. This might have to be
+ fixed. */
int
compare_window_configurations (Lisp_Object configuration1, Lisp_Object configuration2, int ignore_positions)
same combination. This also allows to split a window that is otherwise
too small or of fixed size.
-This variable takes no effect if `window-nest' is non-nil. */);
+This variable takes no effect if `window-combination-limit' is non-nil. */);
Vwindow_splits = Qnil;
- DEFVAR_LISP ("window-nest", Vwindow_nest,
+ DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,
doc: /* Non-nil means splitting a window makes a new parent window.
If this variable is nil, splitting a window will create a new parent
window only if the window has no parent window or the window shall
become a combination orthogonal to the one it it is part of.
-If this variable is non-nil, splitting a window always creates a new
-parent window. If all splits behave this way, each frame's window tree
-is a binary tree and every window but the frame's root window has
-exactly one sibling.
+If this variable is t, splitting a window always creates a new parent
+window. If all splits behave this way, each frame's window tree is a
+binary tree and every window but the frame's root window has exactly one
+sibling.
-The value of this variable is also assigned to the nest status of the
-new parent window. The nest status of a window can be retrieved via the
-function `window-nest' and altered by the function `set-window-nest'. */);
- Vwindow_nest = Qnil;
+Other values are reserved for future use.
+
+The value of this variable is also assigned to the combination_limit
+status of the new parent window. The combination-limit status of a
+window can be retrieved via the function `window-combination-limit' and
+altered by the function `set-window-combination-limit'. */);
+ Vwindow_combination_limit = Qnil;
defsubr (&Sselected_window);
defsubr (&Sminibuffer_window);
defsubr (&Swindow_left_child);
defsubr (&Swindow_next_sibling);
defsubr (&Swindow_prev_sibling);
- defsubr (&Swindow_nest);
- defsubr (&Sset_window_nest);
+ defsubr (&Swindow_combination_limit);
+ defsubr (&Sset_window_combination_limit);
defsubr (&Swindow_use_time);
defsubr (&Swindow_top_line);
defsubr (&Swindow_left_column);
must run the redisplay-end-trigger-hook. */
Lisp_Object redisplay_end_trigger;
- /* Non-nil means this window's child windows are never
- (re-)combined. */
- Lisp_Object nest;
+ /* t means this window's child windows are not (re-)combined. */
+ Lisp_Object combination_limit;
/* Alist of <buffer, window-start, window-point> triples listing
buffers previously shown in this window. */
HCoop / bpt / emacs.git / commitdiff