andros/emacs-gpu
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename window-nest to window-combination-limit.

Browse source 
* 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.
This commit is contained in:
Martin Rudalics 2011-11-16 11:10:40 +01:00
parent ce7ddba001
commit b6f6789018
8 changed files with 139 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
doc/lispref/ChangeLog
View file

@ -1,3 +1,8 @@
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.

85
doc/lispref/windows.texi
View file

@ -632,11 +632,12 @@ the window cannot be resized as demanded, an error is signaled.
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,
@ -859,8 +860,8 @@ Also if this variable is non-@code{nil}, subsequent resizing and
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
@ -931,34 +932,36 @@ height:
@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.
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 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.
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.
@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 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).
@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
@ -966,16 +969,17 @@ return value of @code{nil} means that child windows of @var{window} are
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
______________________________________
@ -997,7 +1001,8 @@ configuration (throughout the following examples we shall assume that
@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
______________________________________
@ -1064,9 +1069,9 @@ follows:
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
______________________________________

8
lisp/ChangeLog
View file

@ -1,3 +1,11 @@
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

2
lisp/cus-start.el
View file

@ -401,7 +401,7 @@ since it could result in memory overflow and make Emacs crash."
(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)

36
lisp/window.el
View file

@ -3083,9 +3083,9 @@ frame. The selected window is not changed by this function."
(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)
@ -3109,15 +3109,15 @@ frame. The selected window is not changed by this function."
(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
@ -3126,7 +3126,7 @@ frame. The selected window is not changed by this function."
;; `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.
@ -3206,7 +3206,8 @@ frame. The selected window is not changed by this function."
;; 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
@ -3584,7 +3585,7 @@ specific buffers."
(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)
@ -3709,9 +3710,11 @@ value can be also stored on disk and read back in a new session."
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))
@ -3735,10 +3738,11 @@ value can be also stored on disk and read back in a new session."
(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)

11
src/ChangeLog
View file

@ -1,3 +1,14 @@
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.

88
src/window.c
View file

@ -465,32 +465,33 @@ Return nil if WINDOW has no previous sibling. */)
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,
@ -1879,7 +1880,7 @@ recombine_windows (Lisp_Object window)
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))
@ -3248,7 +3249,7 @@ make_parent_window (Lisp_Object window, int horflag)
p->start = Qnil;
p->pointm = Qnil;
p->buffer = Qnil;
p->nest = Qnil;
p->combination_limit = Qnil;
p->window_parameters = Qnil;
}
@ -3295,7 +3296,7 @@ make_window (void)
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;
@ -3668,7 +3669,7 @@ set correctly. See the code of `split-window' for how this is done. */)
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);
@ -3677,11 +3678,11 @@ set correctly. See the code of `split-window' for how this is done. */)
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)
@ -3701,7 +3702,7 @@ set correctly. See the code of `split-window' for how this is done. */)
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. */
{
@ -3726,7 +3727,7 @@ set correctly. See the code of `split-window' for how this is done. */)
}
/* 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
@ -3735,8 +3736,9 @@ set correctly. See the code of `split-window' for how this is done. */)
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;
@ -3923,7 +3925,7 @@ Signal an error when WINDOW is the only window on its frame. */)
/* 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. */
@ -5312,7 +5314,7 @@ struct saved_window
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) \
@ -5543,7 +5545,7 @@ the return value is nil. Otherwise the value is t. */)
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);
@ -5821,7 +5823,7 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
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))
{
@ -6284,7 +6286,8 @@ freeze_window_starts (struct frame *f, int freeze_p)
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)
@ -6496,24 +6499,27 @@ variable is non-nil, splitting a window may resize all windows in the
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);
@ -6533,8 +6539,8 @@ function `window-nest' and altered by the function `set-window-nest'. */);
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);

5
src/window.h
View file

@ -258,9 +258,8 @@ struct window
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. */