From: Gerd Moellmann Date: Thu, 6 Jul 2000 14:18:36 +0000 (+0000) Subject: (Fwindow_list): Reverse list at the end. X-Git-Tag: emacs-pretest-21.0.90~2933 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=118ea2426343bea2a8006d689494a92bf08fb61c;p=emacs.git (Fwindow_list): Reverse list at the end. (candidate_window_p): Add parameter OWINDOW. ALL_FRAMES nil means allow windows on OWINDOW's frame, only. (window_loop): Simplified; use Fwindow_list. --- diff --git a/src/window.c b/src/window.c index c0b99f735cd..50f7238205f 100644 --- a/src/window.c +++ b/src/window.c @@ -69,7 +69,8 @@ static int window_fixed_size_p P_ ((struct window *, int, int)); static void enlarge_window P_ ((Lisp_Object, int, int)); static Lisp_Object window_list P_ ((void)); static int add_window_to_list P_ ((struct window *, Lisp_Object *)); -static int candidate_window_p P_ ((Lisp_Object, Lisp_Object, Lisp_Object)); +static int candidate_window_p P_ ((Lisp_Object, Lisp_Object, Lisp_Object, + Lisp_Object)); static Lisp_Object next_window P_ ((Lisp_Object, Lisp_Object, Lisp_Object, int)); static void decode_next_window_args P_ ((Lisp_Object *, Lisp_Object *, @@ -1226,24 +1227,23 @@ window_list () } -/* Value is non-zero if WINODW satisfies the constraints given by - MINIBUF and ALL_FRAMES. +/* Value is non-zero if WINDOW satisfies the constraints given by + OWINDOW, MINIBUF and ALL_FRAMES. - MINIBUF t means WINDOW may be a minibuffer window. - MINIBUF `lambda' means it may not be a minibuffer window. - MINIBUF being a window means WINDOW must be equal to MINIBUF. + MINIBUF t means WINDOW may be minibuffer windows. + `lambda' means WINDOW may not be a minibuffer window. + a window means a specific minibuffer window - ALL_FRAMES t means WINDOW may be on any frame. - ALL_FRAMES nil means WINDOW must not be on a minibuffer-only frame. - ALL_FRAMES `visible' means WINDOW must be on a visible frame. - ALL_FRAMES 0 means WINDOW must be on a visible or iconified frame. - ALL_FRAMES being a frame means WINDOW must be on that frame. - ALL_FRAMES being a window means WINDOW must be on a frame using - the same minibuffer as ALL_FRAMES. */ + ALL_FRAMES t means search all frames, + nil means search just current frame, + `visible' means search just visible frames, + 0 means search visible and iconified frames, + a window means search the frame that window belongs to, + a frame means consider windows on that frame, only. */ static int -candidate_window_p (window, minibuf, all_frames) - Lisp_Object window, minibuf, all_frames; +candidate_window_p (window, owindow, minibuf, all_frames) + Lisp_Object window, owindow, minibuf, all_frames; { struct window *w = XWINDOW (window); struct frame *f = XFRAME (w->frame); @@ -1259,8 +1259,13 @@ candidate_window_p (window, minibuf, all_frames) If it is a window, consider only that one. */ candidate_p = 0; } + else if (EQ (all_frames, Qt)) + candidate_p = 1; else if (NILP (all_frames)) - candidate_p = !FRAME_MINIBUF_ONLY_P (f); + { + xassert (WINDOWP (owindow)); + candidate_p = EQ (w->frame, XWINDOW (owindow)->frame); + } else if (EQ (all_frames, Qvisible)) { FRAME_SAMPLE_VISIBILITY (f); @@ -1271,12 +1276,12 @@ candidate_window_p (window, minibuf, all_frames) FRAME_SAMPLE_VISIBILITY (f); candidate_p = FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f); } - else if (FRAMEP (all_frames)) - candidate_p = EQ (all_frames, w->frame); else if (WINDOWP (all_frames)) candidate_p = (EQ (FRAME_MINIBUF_WINDOW (f), all_frames) || EQ (XWINDOW (all_frames)->frame, w->frame) || EQ (XWINDOW (all_frames)->frame, FRAME_FOCUS_FRAME (f))); + else if (FRAMEP (all_frames)) + candidate_p = EQ (all_frames, w->frame); return candidate_p; } @@ -1356,7 +1361,7 @@ next_window (window, minibuf, all_frames, next_p) /* Scan forward from WINDOW to the end of the window list. */ if (CONSP (list)) for (list = XCDR (list); CONSP (list); list = XCDR (list)) - if (candidate_window_p (XCAR (list), minibuf, all_frames)) + if (candidate_window_p (XCAR (list), window, minibuf, all_frames)) break; /* Scan from the start of the window list up to WINDOW. */ @@ -1364,7 +1369,7 @@ next_window (window, minibuf, all_frames, next_p) for (list = Vwindow_list; CONSP (list) && !EQ (XCAR (list), window); list = XCDR (list)) - if (candidate_window_p (XCAR (list), minibuf, all_frames)) + if (candidate_window_p (XCAR (list), window, minibuf, all_frames)) break; if (CONSP (list)) @@ -1386,7 +1391,8 @@ next_window (window, minibuf, all_frames, next_p) if (WINDOWP (candidate)) break; } - else if (candidate_window_p (XCAR (list), minibuf, all_frames)) + else if (candidate_window_p (XCAR (list), window, minibuf, + all_frames)) candidate = XCAR (list); } @@ -1507,7 +1513,7 @@ argument ALL_FRAMES is non-nil, cycle through all frames.") DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0, - "Return a list windows in canonical ordering.\n\ + "Return a list of windows in canonical ordering.\n\ Arguments are like for `next-window'.") (window, minibuf, all_frames) Lisp_Object minibuf, all_frames; @@ -1518,10 +1524,10 @@ Arguments are like for `next-window'.") list = Qnil; for (tail = window_list (); CONSP (tail); tail = XCDR (tail)) - if (candidate_window_p (XCAR (tail), minibuf, all_frames)) + if (candidate_window_p (XCAR (tail), window, minibuf, all_frames)) list = Fcons (XCAR (tail), list); - return list; + return Fnreverse (list); } @@ -1550,32 +1556,30 @@ enum window_loop static Lisp_Object window_loop (type, obj, mini, frames) enum window_loop type; - register Lisp_Object obj, frames; + Lisp_Object obj, frames; int mini; { - register Lisp_Object w; - register Lisp_Object best_window; - register Lisp_Object next_window; - register Lisp_Object last_window; - FRAME_PTR frame; - Lisp_Object frame_arg; - frame_arg = Qt; - + Lisp_Object window, windows, best_window, frame_arg; + struct frame *f; + /* If we're only looping through windows on a particular frame, frame points to that frame. If we're looping through windows on all frames, frame is 0. */ if (FRAMEP (frames)) - frame = XFRAME (frames); + f = XFRAME (frames); else if (NILP (frames)) - frame = SELECTED_FRAME (); + f = SELECTED_FRAME (); else - frame = 0; - if (frame) + f = NULL; + + if (f) frame_arg = Qlambda; else if (XFASTINT (frames) == 0) frame_arg = frames; else if (EQ (frames, Qvisible)) frame_arg = frames; + else + frame_arg = Qt; /* frame_arg is Qlambda to stick to one frame, Qvisible to consider all visible frames, @@ -1583,11 +1587,11 @@ window_loop (type, obj, mini, frames) /* Pick a window to start with. */ if (WINDOWP (obj)) - w = obj; - else if (frame) - w = FRAME_SELECTED_WINDOW (frame); + window = obj; + else if (f) + window = FRAME_SELECTED_WINDOW (f); else - w = FRAME_SELECTED_WINDOW (SELECTED_FRAME ()); + window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ()); /* Figure out the last window we're going to mess with. Since Fnext_window, given the same options, is guaranteed to go in a @@ -1596,178 +1600,162 @@ window_loop (type, obj, mini, frames) We can't just wait until we hit the first window again, because it might be deleted. */ - last_window = Fprevious_window (w, mini ? Qt : Qnil, frame_arg); - + windows = Fwindow_list (window, mini ? Qt : Qnil, frame_arg); + GCPRO1 (windows); best_window = Qnil; - for (;;) + + for (; CONSP (windows); windows = CDR (windows)) { - /* Pick the next window now, since some operations will delete - the current window. */ - next_window = Fnext_window (w, mini ? Qt : Qnil, frame_arg); - - /* Note that we do not pay attention here to whether - the frame is visible, since Fnext_window skips non-visible frames - if that is desired, under the control of frame_arg. */ - if (! MINI_WINDOW_P (XWINDOW (w)) + struct window *w; + + window = XCAR (windows); + w = XWINDOW (window); + + /* Note that we do not pay attention here to whether the frame + is visible, since Fwindow_list skips non-visible frames if + that is desired, under the control of frame_arg. */ + if (!MINI_WINDOW_P (w) /* For UNSHOW_BUFFER, we must always consider all windows. */ || type == UNSHOW_BUFFER || (mini && minibuf_level > 0)) switch (type) { case GET_BUFFER_WINDOW: - if (XBUFFER (XWINDOW (w)->buffer) == XBUFFER (obj) + if (EQ (w->buffer, 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; + && (MINI_WINDOW_P (w) + ? EQ (window, minibuf_window) + : 1)) + { + UNGCPRO; + return window; + } break; case GET_LRU_WINDOW: /* t as arg means consider only full-width windows */ - if (!NILP (obj) && !WINDOW_FULL_WIDTH_P (XWINDOW (w))) + if (!NILP (obj) && !WINDOW_FULL_WIDTH_P (w)) break; /* Ignore dedicated windows and minibuffers. */ - if (MINI_WINDOW_P (XWINDOW (w)) - || !NILP (XWINDOW (w)->dedicated)) + if (MINI_WINDOW_P (w) || !NILP (w->dedicated)) break; if (NILP (best_window) || (XFASTINT (XWINDOW (best_window)->use_time) - > XFASTINT (XWINDOW (w)->use_time))) - best_window = w; + > XFASTINT (w->use_time))) + best_window = window; break; case DELETE_OTHER_WINDOWS: - if (XWINDOW (w) != XWINDOW (obj)) - Fdelete_window (w); + if (!EQ (window, obj)) + Fdelete_window (window); break; case DELETE_BUFFER_WINDOWS: - if (EQ (XWINDOW (w)->buffer, obj)) + if (EQ (w->buffer, obj)) { - FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (w))); + struct frame *f = XFRAME (WINDOW_FRAME (w)); /* If this window is dedicated, and in a frame of its own, kill the frame. */ - if (EQ (w, FRAME_ROOT_WINDOW (f)) - && !NILP (XWINDOW (w)->dedicated) + if (EQ (window, FRAME_ROOT_WINDOW (f)) + && !NILP (w->dedicated) && other_visible_frames (f)) { /* Skip the other windows on this frame. There might be one, the minibuffer! */ - if (! EQ (w, last_window)) - while (f == XFRAME (WINDOW_FRAME (XWINDOW (next_window)))) - { - /* As we go, check for the end of the loop. - We mustn't start going around a second time. */ - if (EQ (next_window, last_window)) - { - last_window = w; - break; - } - next_window = Fnext_window (next_window, - mini ? Qt : Qnil, - frame_arg); - } + while (CONSP (XCDR (windows)) + && EQ (XWINDOW (XCAR (windows))->frame, + XWINDOW (XCAR (XCDR (windows)))->frame)) + windows = XCDR (windows); + /* Now we can safely delete the frame. */ - Fdelete_frame (WINDOW_FRAME (XWINDOW (w)), Qnil); + Fdelete_frame (w->frame, Qnil); + } + else if (NILP (w->parent)) + { + /* If we're deleting the buffer displayed in the + only window on the frame, find a new buffer to + display there. */ + Lisp_Object buffer; + buffer = Fother_buffer (obj, Qnil, w->frame); + if (NILP (buffer)) + buffer = Fget_buffer_create (build_string ("*scratch*")); + Fset_window_buffer (window, buffer); + if (EQ (window, selected_window)) + Fset_buffer (w->buffer); } else - /* If we're deleting the buffer displayed in the only window - on the frame, find a new buffer to display there. */ - if (NILP (XWINDOW (w)->parent)) - { - Lisp_Object new_buffer; - new_buffer = Fother_buffer (obj, Qnil, - XWINDOW (w)->frame); - if (NILP (new_buffer)) - new_buffer - = Fget_buffer_create (build_string ("*scratch*")); - Fset_window_buffer (w, new_buffer); - if (EQ (w, selected_window)) - Fset_buffer (XWINDOW (w)->buffer); - } - else - Fdelete_window (w); + Fdelete_window (window); } break; case GET_LARGEST_WINDOW: - /* Ignore dedicated windows and minibuffers. */ - if (MINI_WINDOW_P (XWINDOW (w)) - || !NILP (XWINDOW (w)->dedicated) - || NILP (best_window)) - break; { - struct window *best_window_ptr = XWINDOW (best_window); - struct window *w_ptr = XWINDOW (w); + struct window *b; + + /* Ignore dedicated windows and minibuffers. */ + if (MINI_WINDOW_P (w) + || !NILP (w->dedicated) + || NILP (best_window)) + break; + + b = XWINDOW (best_window); if (NILP (best_window) - || (XFASTINT (w_ptr->height) * XFASTINT (w_ptr->width) - > (XFASTINT (best_window_ptr->height) - * XFASTINT (best_window_ptr->width)))) - best_window = w; + || (XFASTINT (w->height) * XFASTINT (w->width) + > (XFASTINT (b->height) * XFASTINT (b->width)))) + best_window = window; } break; case UNSHOW_BUFFER: - if (EQ (XWINDOW (w)->buffer, obj)) + if (EQ (w->buffer, obj)) { + Lisp_Object buffer; + struct frame *f = XFRAME (w->frame); + /* 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, XWINDOW (w)->frame); - if (NILP (another_buffer)) - another_buffer - = Fget_buffer_create (build_string ("*scratch*")); + buffer = Fother_buffer (obj, Qnil, w->frame); + if (NILP (buffer)) + buffer = Fget_buffer_create (build_string ("*scratch*")); + /* If this window is dedicated, and in a frame of its own, kill the frame. */ - if (EQ (w, FRAME_ROOT_WINDOW (f)) - && !NILP (XWINDOW (w)->dedicated) + if (EQ (window, FRAME_ROOT_WINDOW (f)) + && !NILP (w->dedicated) && other_visible_frames (f)) { /* Skip the other windows on this frame. There might be one, the minibuffer! */ - if (! EQ (w, last_window)) - while (f == XFRAME (WINDOW_FRAME (XWINDOW (next_window)))) - { - /* As we go, check for the end of the loop. - We mustn't start going around a second time. */ - if (EQ (next_window, last_window)) - { - last_window = w; - break; - } - next_window = Fnext_window (next_window, - mini ? Qt : Qnil, - frame_arg); - } + while (CONSP (XCDR (windows)) + && EQ (XWINDOW (XCAR (windows))->frame, + XWINDOW (XCAR (XCDR (windows)))->frame)) + windows = XCDR (windows); + /* Now we can safely delete the frame. */ - Fdelete_frame (WINDOW_FRAME (XWINDOW (w)), Qnil); + Fdelete_frame (w->frame, Qnil); } else { /* Otherwise show a different buffer in the window. */ - XWINDOW (w)->dedicated = Qnil; - Fset_window_buffer (w, another_buffer); - if (EQ (w, selected_window)) - Fset_buffer (XWINDOW (w)->buffer); + w->dedicated = Qnil; + Fset_window_buffer (window, buffer); + if (EQ (window, selected_window)) + Fset_buffer (w->buffer); } } break; /* Check for a window that has a killed buffer. */ case CHECK_ALL_WINDOWS: - if (! NILP (XWINDOW (w)->buffer) - && NILP (XBUFFER (XWINDOW (w)->buffer)->name)) + if (! NILP (w->buffer) + && NILP (XBUFFER (w->buffer)->name)) abort (); + break; } - - if (EQ (w, last_window)) - break; - - w = next_window; } + UNGCPRO; return best_window; }