23.0.60; list-buffers in recursive edit

23.0.60; list-buffers in recursive edit

[Nick Roberts]

Window handling goes crazy in a recursive edit, e.g. after an error is
triggered with debug-on-error set to t.

With split windows, M-x list-buffers displays the buffer list in the current
window, `o' in the buffer list (Buffer-menu-other-window) works like `f'
(Buffer-menu-this-window) or sometimes pops up or displays in a new frame.

In GNU Emacs 23.0.60.120 (i686-pc-linux-gnu, GTK+ Version 2.10.11)
 of 2008-06-08 on kahikatea.snap.net.nz
Windowing system distributor `The X.Org Foundation', version 11.0.70200000
configured using `configure  'CFLAGS=-g3' '--enable-font-backend''

Important settings:
  value of $LC_ALL: nil
  value of $LC_COLLATE: nil
  value of $LC_CTYPE: nil
  value of $LC_MESSAGES: nil
  value of $LC_MONETARY: nil
  value of $LC_NUMERIC: nil
  value of $LC_TIME: nil
  value of $LANG: en_NZ.UTF-8
  value of $XMODIFIERS: nil
  locale-coding-system: utf-8-unix
  default-enable-multibyte-characters: t

Major mode: Emacs-Lisp

Minor modes in effect:
  show-paren-mode: t
  tooltip-mode: t
  mouse-wheel-mode: t
  menu-bar-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  global-auto-composition-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t
  line-number-mode: t
  transient-mark-mode: t

Recent input:
1 3 8 4 <return> <home> <down-mouse-1> <mouse-1> C-x 
C-b <help-echo> <help-echo> <help-echo> <down-mouse-1> 
<mouse-1> <down-mouse-1> <mouse-1> o <down-mouse-1> 
<mouse-1> C-x C-b <help-echo> <help-echo> <down-mouse-1> 
<mouse-1> <help-echo> o <down-mouse-1> <mouse-1> C-x 
5 2 <switch-frame> <switch-frame> <down-mouse-1> <mouse-1> 
<down-mouse-1> <mouse-movement> <mouse-1> C-x C-b <help-echo> 
<down-mouse-1> <mouse-movement> <mouse-1> <help-echo> 
<switch-frame> <down-mouse-1> <mouse-1> <down-mouse-2> 
<mouse-2> <switch-frame> <down-mouse-1> <mouse-1> <help-echo> 
<help-echo> <help-echo> <help-echo> <help-echo> <down-mouse-1> 
<mouse-movement> <mouse-1> M-x g o t SPC c h a <tab> 
<return> 1 3 8 4 <return> <down-mouse-1> <mouse-1> 
<f6> <f6> <f6> <end> <home> <next> <down-mouse-1> <mouse-1> 
C-x C-b <help-echo> <help-echo> <switch-frame> <down-mouse-1> 
<mouse-movement> <mouse-1> C-h c o <help-echo> <help-echo> 
<switch-frame> <down-mouse-1> <mouse-1> <down-mouse-1> 
<mouse-movement> <mouse-1> M-x v m SPC <backspace> 
<backspace> <backspace> r e p o r t SPC e m a <tab> 
<return> C-g C-x C-f <backspace> <backspace> <backspace> 
<backspace> <backspace> <backspace> <backspace> C h 
<tab> <return> C-s b u f f e r - <f5> <f5> <f5> <f5> 
<f5> <f5> <f5> <f5> <f5> <f5> C-s C-s m e n <home> 
C-h c C-x C-b C-g C-s l i s t - b u <home> C-g M-x 
r e p o r t SPC r <backspace> e n <backspace> m SPC 
SPC C-g C-h k C-x C-b <down-mouse-1> <mouse-movement> 
<mouse-1> <switch-frame> <down-mouse-1> <mouse-movement> 
<mouse-1> <down-mouse-1> <mouse-1> <switch-frame> <down-mouse-1> 
<drag-mouse-1> <down-mouse-1> <mouse-movement> <mouse-1> 
<down-mouse-1> <mouse-1> <down-mouse-1> <mouse-movement> 
<mouse-1> C-x C-b <help-echo> <switch-frame> <down-mouse-2> 
<mouse-2> q <down-mouse-1> <mouse-1> M-x v m <backspace> 
<backspace> r e p o r t SPC e m a SPC b u SPC <return> 
l i s t - C-g M-x <up> <up> <up> <return> <help-echo> 
<help-echo> M-x <up> <return> <help-echo> <down-mouse-1> 
<mouse-movement> <mouse-1> M-x <up> <return> <help-echo> 
<help-echo> <help-echo> <help-echo> <switch-frame> 
<down-mouse-1> <mouse-movement> <mouse-1> q <switch-frame> 
<down-mouse-1> <mouse-movement> <mouse-1> q <down-mouse-1> 
<mouse-1> <help-echo> <help-echo> M-x C-g <down-mouse-1> 
<mouse-movement> <mouse-1> <f7> M-x <up> <up> <ret
urn>

Recent messages:
Mark saved where search started
Mark set
Quit [2 times]
Type "q" to restore this window.
Back to top level.
Quit
Entering debugger...
Back to top level.
Quit
Undo!


-- 
Nick                                           http://www.inet.net.nz/~nickrob

Re: 23.0.60; list-buffers in recursive edit

[Nick Roberts]

 > 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.

-- 
Nick                                           http://www.inet.net.nz/~nickrob

Re: 23.0.60; list-buffers in recursive edit

[martin rudalics]

[-- Attachment #1: Type: text/plain, Size: 422 bytes --]

 >  > 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.

[-- Attachment #2: window.el.patch --]
[-- Type: text/plain, Size: 9219 bytes --]

*** 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)

Re: 23.0.60; list-buffers in recursive edit

[Nick Roberts]

martin rudalics writes:
 >  >  > 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.

It looks like you've committed that patch and, indeed, it does work as before.
It would be nice to have a testuite of some kind to prevent such regressions
but I'm not sure how it would work for GUI operations.  Perhaps there could
just be a prescribed manual test.

-- 
Nick                                           http://www.inet.net.nz/~nickrob