Re: [PATCH] Fix display-buffer-use-some-window to honor reusable-frames

[martin rudalics <rudalics@gmx.at>]

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

 >> We need a way to bump the time stamp of _any_ window used.
 >
 > Sorry, I don't understand what that means in practice.  Specifically,
 > what do you mean by "any window used"? used by whom and under what
 > circumstances? or do you mean any window that is currently displayed
 > on all the frames?

I mean "any window used" by 'display-buffer' to display a buffer.

 >> Otherwise,
 >> the various action functions will continue to fight each other.  Lars
 >> wanted to go the way XEmacs did but stopped in the middle.  And XEmacs
 >> uses
 >>
 >>                 (if (window-buffer window)
 >>                     (save-excursion
 >>                       (save-selected-window
 >>                         (select-window window)
 >>                         (record-buffer (window-buffer window)))))
 >>
 >> to bump the use time of every window used by 'display-buffer'.
 >
 > You mean, do this every time display-buffer is called and selects some
 > window?  But that would change our behavior for all the callers of
 > display-buffer, whose names is a legion.  Whereas the intent was to
 > provide an optional feature that hopefully doesn't affect any existing
 > behaviors.

It would change the behavior iff a user or caller had added a non-nil
'bump-time-stamp' entry to the alist.  Existing behaviors would not be
affected.

I'll give you an example.  Apply the attached bump-use-time.diff.  Now
with emacs -Q evaluate:

(let* ((window-combination-resize t))
   (split-window)
   (split-window)
   (display-buffer (get-buffer-create "*foo*"))
   (display-buffer (get-buffer-create "*bar*")))

*foo* is nowhere displayed because 'display-buffer' displayed *bar* in
the least recently used window instead.  This is the behavior Lars
wanted to avoid.

Now instead do

(let* ((window-combination-resize t))
   (split-window)
   (split-window)
   (display-buffer
    (get-buffer-create "*foo*") '(nil (bump-use-time . t)))
   (display-buffer
    (get-buffer-create "*bar*") '(nil (bump-use-time . t))))

This is the behavior Lars wanted.  Look, no separate action function
needed at all.  If anyone has a solution to that problem that's simpler
than this two-liner, I'll be all ears.

 >>   > Would it work to just temporarily select the window inside
 >>   > display-buffer-use-least-recent-window, so that its use time is bumped
 >>   > without any sneaky primitives?  Then we could remove
 >>   > window-bump-use-time.
 >>
 >> As Lars conceived it, independent 'display-buffer' calls should be able
 >> to build on previous ones.  Otherwise, we could write a function like
 >> 'display-many-buffers-at-once', within that function mark all windows
 >> used as temporarily dedicated to their buffers, and at the end restore
 >> the previous dedicated states of these windows.  Obviously, a function
 >> like 'display-many-buffers-at-once' would not qualify as buffer display
 >> action function.
 >
 > What do you mean by "independent calls"?  Or what are "dependent
 > calls" for this purpose?  Without understanding that, I cannot see how
 > what you wrote here answers my question, sorry.

A dependent call would be one inside a function like
'display-many-buffers-at-once' where you want to avoid that the same
window is used for displaying first one and then another buffer.  Any
other calls would be independent.

But to return to your question "Would it work to just temporarily select
the window inside display-buffer-use-least-recent-window, so that its
use time is bumped without any sneaky primitives?".  The XEmacs solution
cited above does precisely that and that's why I posted it here.

Why you would call a primitive like 'window-bump-use-time' "sneaky" is
beyond my comprehension.  Is it because I originally proposed it?

martin

[-- Attachment #2: bump-use-time.diff --]
[-- Type: text/x-patch, Size: 1434 bytes --]

diff --git a/lisp/window.el b/lisp/window.el
index 7d8ee48635..ef45f629c5 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -7276,6 +7276,10 @@ window--display-buffer
       ;; Unless WINDOW already shows BUFFER reset its dedicated flag.
       (set-window-dedicated-p window nil)
       (set-window-buffer window buffer))
+    (when (assq 'bump-use-time alist)
+      ;; Bump WINDOW's use time so 'get-lru-window' will try to avoid
+      ;; it.
+      (window-bump-use-time window))
     (let ((alist-dedicated (assq 'dedicated alist)))
       ;; Maybe dedicate WINDOW to BUFFER if asked for.
       (cond
diff --git a/src/window.c b/src/window.c
index 90fa6ac2df..a20ac70cbf 100644
--- a/src/window.c
+++ b/src/window.c
@@ -773,13 +773,18 @@ DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
 
 DEFUN ("window-bump-use-time", Fwindow_bump_use_time,
        Swindow_bump_use_time, 0, 1, 0,
-       doc: /* Mark WINDOW as having been most recently used.
+       doc: /* Mark WINDOW as most recently used after the selected window.
 WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
   struct window *w = decode_live_window (window);
+  struct window *sw = XWINDOW (selected_window);
 
-  w->use_time = ++window_select_count;
+  if (w != sw)
+    {
+      w->use_time = ++window_select_count;
+      sw->use_time = ++window_select_count;
+    }
 
   return Qnil;
 }