Re: 23.0.60; list-buffers in recursive edit

[martin rudalics]

>  > Window handling goes crazy in a recursive edit, e.g. after an error is
>  > triggered with debug-on-error set to t.
>
> Actually it looks like it happens normally too, i.e., not just in a recursive
> edit.

Thanks for reporting.  I' m not quite sure whether you found the same
bug as Michael.  Please try the patch I sent to him and tell me whether
it improves anything.  Otherwise I need a more precise recipe.

*** window.el.~1.137.~  Fri Jun  6 10:01:10 2008
--- window.el   Sun Jun  8 10:24:30 2008
***************
*** 741,771 ****
    :group 'windows)
  
  (defcustom split-window-preferred-function nil
!   "How `display-buffer' shall split windows.
! Choices are `Vertically', `Horizontally', and `Sensibly' where
! the latter attempts to split wide windows horizontally, narrow
! ones vertically.  Alternatively, you can set this to a function
! called with a window as single argument to split that window in
! two and return the new window."
!   :type '(choice
!         (const :tag "Vertically" nil)
!         (const :tag "Horizontally" horizontally)
!         (const :tag "Sensibly" sensibly)
!         (function :tag "Function"))
    :version "23.1"
    :group 'windows)
  
  (defcustom split-height-threshold 80
!   "Minimum height of window to be split vertically by `display-buffer'.
! If there is only one window, it can be split regardless of this."
    :type 'number
    :version "23.1"
    :group 'windows)
  
  (defcustom split-width-threshold 160
!   "Minimum width of window to be split horizontally by `display-buffer'.
! If there is only one window, it can be split regardless of this."
!   :type 'number
    :version "23.1"
    :group 'windows)
  
--- 741,775 ----
    :group 'windows)
  
  (defcustom split-window-preferred-function nil
!   "Function for `display-buffer' to split windows.
! If non-nil a function called with a window as single argument to
! split that window in two and return the new window.  If nil
! `display-buffer' will split the window according to the values of
! `split-height-threshold' and `split-width-threshold'."
!   :type '(choice (const nil) (function :tag "Function"))
    :version "23.1"
    :group 'windows)
  
  (defcustom split-height-threshold 80
!   "Minimum height of window to be split vertically.
! If the value is a number `display-buffer' can split a window only
! if it has at least as many lines.  If the value is nil
! `display-buffer' cannot split the window vertically.  If the
! window is the only window on its frame it can be split regardless
! of this value."
!   :type '(choice (const :tag "inhibit" nil)
!                (number :tag "lines"))
    :type 'number
    :version "23.1"
    :group 'windows)
  
  (defcustom split-width-threshold 160
!   "Minimum width of window to be split horizontally.
! If the value is a number `display-buffer' can split a window only
! if it has at least as many columns.  If the value is nil
! `display-buffer' cannot split the window horizontally."
!   :type '(choice (const :tag "inhibit" nil)
!                (number :tag "columns"))
    :version "23.1"
    :group 'windows)
  
***************
*** 780,787 ****
  - `window-size-fixed' is either nil or equals `width' for the buffer of
    WINDOW.
  
! - WINDOW is at least as high as `split-height-threshold' or it is
!   the only window on its frame.
  
  - When WINDOW is split evenly, the emanating windows are at least
    `window-min-height' lines tall and can accomodate at least one
--- 784,790 ----
  - `window-size-fixed' is either nil or equals `width' for the buffer of
    WINDOW.
  
! - WINDOW is at least as high as `split-height-threshold'.
  
  - When WINDOW is split evenly, the emanating windows are at least
    `window-min-height' lines tall and can accomodate at least one
***************
*** 805,861 ****
          ;; and at least twice as wide as `window-min-width' and 2 (the
          ;; latter value is hardcoded).
          (and (memq window-size-fixed '(nil height))
               (>= (window-width window)
                   (max split-width-threshold
                        (* 2 (max window-min-width 2)))))
        ;; A window can be split vertically when its height is not
!       ;; fixed, it is at least `split-height-threshold' lines high or
!       ;; the only window on its frame, and it is at least twice as
!       ;; high as `window-min-height' and 2 if it has a modeline or 1.
        (and (memq window-size-fixed '(nil width))
             (>= (window-height window)
!                (max (if (one-window-p 'nomini) 0 split-height-threshold)
                      (* 2 (max window-min-height
                                (if mode-line-format 2 1))))))))))
  
  (defun window--try-to-split-window (window)
    "Split window WINDOW if it is splittable.
! See `split-window-preferred-function' for how WINDOW shall be
! split.  See `window--splittable-p' for how to determine whether a
! window is splittable.  If WINDOW can be split, return the value
! returned by `split-window' or `split-window-preferred-function'."
    (when (and (window-live-p window)
             ;; Testing `window-full-width-p' here hardly makes any
             ;; sense nowadays.  This can be done more intuitively by
             ;; setting up `split-width-threshold' appropriately.
             (not (frame-parameter (window-frame window) 'unsplittable)))
!     (or (and (not split-window-preferred-function)
!            (window--splittable-p window)
             (split-window window))
!       (and (eq split-window-preferred-function 'horizontally)
!            (window--splittable-p window t)
             (split-window window nil t))
!       (and (eq split-window-preferred-function 'sensibly)
!            ;; The following naive aspect-ratio test should become
!            ;; more sensible.
!            (or (and (> (window-width window) (window-height window))
!                     (window--splittable-p window t)
!                     (split-window window nil t))
!                (and (window--splittable-p window)
!                     (split-window window))))
        (and (functionp split-window-preferred-function)
             (funcall split-window-preferred-function window)))))
  
  (defun window--frame-usable-p (frame)
    "Return frame FRAME if it can be used to display another buffer."
!   (let ((window (frame-root-window frame)))
!     ;; `frame-root-window' may be an internal window which is considered
!     ;; "dead" by `window-live-p'.  Hence if `window' is not live we
!     ;; implicitly know that `frame' has a visible window we can use.
!     (when (or (not (window-live-p window))
!             (and (not (window-minibuffer-p window))
!                  (not (window-dedicated-p window))))
!       frame)))
  
  (defcustom even-window-heights t
    "If non-nil `display-buffer' will try to even window heights.
--- 808,861 ----
          ;; and at least twice as wide as `window-min-width' and 2 (the
          ;; latter value is hardcoded).
          (and (memq window-size-fixed '(nil height))
+              (numberp split-width-threshold)
               (>= (window-width window)
                   (max split-width-threshold
                        (* 2 (max window-min-width 2)))))
        ;; A window can be split vertically when its height is not
!       ;; fixed, it is at least `split-height-threshold' lines high,
!       ;; and it is at least twice as high as `window-min-height' and 2
!       ;; if it has a modeline or 1.
        (and (memq window-size-fixed '(nil width))
+            (numberp split-height-threshold)
             (>= (window-height window)
!                (max split-height-threshold
                      (* 2 (max window-min-height
                                (if mode-line-format 2 1))))))))))
  
  (defun window--try-to-split-window (window)
    "Split window WINDOW if it is splittable.
! See `window--splittable-p' for how to determine whether a window
! is splittable.  If WINDOW can be split, return the value returned
! by `split-window' or `split-window-preferred-function'."
    (when (and (window-live-p window)
             ;; Testing `window-full-width-p' here hardly makes any
             ;; sense nowadays.  This can be done more intuitively by
             ;; setting up `split-width-threshold' appropriately.
             (not (frame-parameter (window-frame window) 'unsplittable)))
!     (or (and (window--splittable-p window)
             (split-window window))
!       (and (window--splittable-p window t)
             (split-window window nil t))
!       (and (with-selected-window window
!              (one-window-p 'nomini))
!            (let ((split-height-threshold 0))
!              (window--splittable-p window)
!              (split-window window)))
        (and (functionp split-window-preferred-function)
             (funcall split-window-preferred-function window)))))
  
  (defun window--frame-usable-p (frame)
    "Return frame FRAME if it can be used to display another buffer."
!   (when (framep frame)
!     (let ((window (frame-root-window frame)))
!       ;; `frame-root-window' may be an internal window which is considered
!       ;; "dead" by `window-live-p'.  Hence if `window' is not live we
!       ;; implicitly know that `frame' has a visible window we can use.
!       (when (or (not (window-live-p window))
!               (and (not (window-minibuffer-p window))
!                    (not (window-dedicated-p window))))
!       frame))))
  
  (defcustom even-window-heights t
    "If non-nil `display-buffer' will try to even window heights.
***************
*** 1011,1017 ****
           (window--display-buffer-2 buffer window-to-use)))
       ((setq window-to-use
            ;; Reuse an existing window.
!           (or (get-buffer-window buffer 'visible)
                (get-largest-window 'visible nil)
                (get-buffer-window buffer 0)
                (get-largest-window 0 nil)
--- 1011,1018 ----
           (window--display-buffer-2 buffer window-to-use)))
       ((setq window-to-use
            ;; Reuse an existing window.
!           (or (get-lru-window frame-to-use)
!               (get-buffer-window buffer 'visible)
                (get-largest-window 'visible nil)
                (get-buffer-window buffer 0)
                (get-largest-window 0 nil)