From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.io!.POSTED.blaine.gmane.org!not-for-mail From: Alan Mackenzie Newsgroups: gmane.emacs.devel Subject: Re: Stop frames stealing eachothers' minibuffers! Date: Tue, 5 Jan 2021 18:07:18 +0000 Message-ID: References: <0d14bfc4-8e8e-d3b9-e0e1-ee4bf2e6449d@gmx.at> <20201125210947.GB8228@ACM> <50c96c83-01b4-d2b8-ff90-82c9d706e268@gmx.at> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="KR1Ny43umX9KauN5" Injection-Info: ciao.gmane.io; posting-host="blaine.gmane.org:116.202.254.214"; logging-data="9307"; mail-complaints-to="usenet@ciao.gmane.io" Cc: Andrii Kolomoiets , emacs-devel@gnu.org, enometh@meer.net, Stefan Monnier , Gregory Heytings , Eli Zaretskii To: martin rudalics Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane-mx.org@gnu.org Tue Jan 05 19:14:56 2021 Return-path: Envelope-to: ged-emacs-devel@m.gmane-mx.org Original-Received: from lists.gnu.org ([209.51.188.17]) by ciao.gmane.io with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kwqr9-0002HO-ON for ged-emacs-devel@m.gmane-mx.org; Tue, 05 Jan 2021 19:14:55 +0100 Original-Received: from localhost ([::1]:33952 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kwqr8-0006RX-PG for ged-emacs-devel@m.gmane-mx.org; Tue, 05 Jan 2021 13:14:54 -0500 Original-Received: from eggs.gnu.org ([2001:470:142:3::10]:41876) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kwqjt-0007y1-DN for emacs-devel@gnu.org; Tue, 05 Jan 2021 13:07:25 -0500 Original-Received: from colin.muc.de ([193.149.48.1]:33047 helo=mail.muc.de) by eggs.gnu.org with smtp (Exim 4.90_1) (envelope-from ) id 1kwqjp-0003nC-Vk for emacs-devel@gnu.org; Tue, 05 Jan 2021 13:07:25 -0500 Original-Received: (qmail 50952 invoked by uid 3782); 5 Jan 2021 18:07:19 -0000 Original-Received: from acm.muc.de (p4fe15a15.dip0.t-ipconnect.de [79.225.90.21]) by colin.muc.de (tmda-ofmipd) with ESMTP; Tue, 05 Jan 2021 19:07:18 +0100 Original-Received: (qmail 32333 invoked by uid 1000); 5 Jan 2021 18:07:18 -0000 Content-Disposition: inline In-Reply-To: <50c96c83-01b4-d2b8-ff90-82c9d706e268@gmx.at> X-Delivery-Agent: TMDA/1.1.12 (Macallan) X-Primary-Address: acm@muc.de Received-SPF: pass client-ip=193.149.48.1; envelope-from=acm@muc.de; helo=mail.muc.de X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane-mx.org@gnu.org Original-Sender: "Emacs-devel" Xref: news.gmane.io gmane.emacs.devel:262534 Archived-At: --KR1Ny43umX9KauN5 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hello, Martin and everybody else. On Mon, Jan 04, 2021 at 10:20:11 +0100, martin rudalics wrote: [ .... ] > > 3/- From Gregory: Start emacs -Q, and set enable-recursive-minibuffers > > to t. Do C-x C-f C-x 5 o twice, then C-x C-f a third time. It was > > possible to enter filenames for and visit files for the innermost two > > minibuffers, but not the outermost one. This has (I believe) been > > fixed. > I'm not sure what's missing here, probably a C-x 5 2 to get the frame > C-x 5 o can act upon. So I let Gregory tell whether this has been > fixed. What I see is that with 'enable-recursive-minibuffers' t C-x 5 2 > followed by two C-x C-f C-x 5 o > - doesn't get me _always_ into the minibuffer window of the frame > switched to (I'm not sure whether it should and under which > circumstances - this should be clarified), I don't think it should, in general, unless the miniwindow is (still) the frame's current window. I've found out why, in Gregory's scenario, after the "middle" RET to visit a file, point was not moving back to the "middle frame": it's because select_frame is insufficient of itself to move X-Window's focus, which stays in the "old" frame. Any command now causes a "switch-frame" event which moves the minibuffers back into the "old" frame, which isn't what we want. The solution (a bit ugly) is to call the lisp function select-frame-set-input-focus rather than just do_switch_frame near the end of read_minibuf. > and > - typing C-g to quit an inner invocation of C-x C-f sometimes gets me a > catatonic minibuffer window where either nothing is displayed or just > a simple "Quit" appears - I have to get out of it via C-x o. Yes. I still have some work to do in this area. > > 4/- With minibuffer-follows-selected-frame nil, and > > enable-recursive-minibuffers t, there were problems caused by editing > > outer level minibuffers whilst an inner level buffer was still active. > > I've tried to fix this by giving outer level MBs the keymap > > minibuffer-inactive-mode-map temporariliy whilst a recursive MB is > > active. > How do I edit an outer level minibuffer whilst an inner level buffer is > active? At the moment, you can't. This isn't good. What do you think of the following solution? Instead of setting outer minibuffers' maps temporarily to minibuffer-inactive-mode-map, I could amend exit-minibuffer so that it would throw an error when there was a more nested active minibuffer, but leave the current minibuffers untouched. Also, C-g should then abort the current minibuffer's caller, together with those of any more nested MBs. [ .... ] The change in the current version of the patch (attached) is that, as already mentioned, select-frame-set-input-focus is called rather than just do_select_frame from near the end of read_minibuf. Also, that call has been moved from just after the recursive edit to the very end of read_minibuf. Also, move_minibuffer_onto_frame now moves the entire stack of minibuffers, not just the current one (it is not called when minibuffers-follows-selected-frame is nil). How would you feel about committing this patch? It is an improvement over the current state, even though not yet finished. > martin -- Alan Mackenzie (Nuremberg, Germany). --KR1Ny43umX9KauN5 Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="diff.20210105.diff" diff --git a/doc/emacs/mini.texi b/doc/emacs/mini.texi index c7c8fb30ac..f81e64bdf9 100644 --- a/doc/emacs/mini.texi +++ b/doc/emacs/mini.texi @@ -76,9 +76,13 @@ Basic Minibuffer the user option @code{minibuffer-follows-selected-frame} to @code{nil}, then the minibuffer stays in the frame where you opened it, and you must switch back to that frame in order to complete (or -abort) the current command. Note that the effect of the command, when -you finally finish using the minibuffer, always takes place in the -frame where you first opened it. +abort) the current command. If you set that option to a value which +is neither @code{nil} nor @code{t}, the minibuffer moves frame only +after a recursive minibuffer has been opened in the current command +(@pxref{Recursive Mini,,, elisp}). This option is mainly to retain +(approximately) the behavior prior to Emacs 28.1. Note that the +effect of the command, when you finally finish using the minibuffer, +always takes place in the frame where you first opened it. @node Minibuffer File @section Minibuffers for File Names diff --git a/etc/NEWS b/etc/NEWS index b294ff1d23..bd707cb047 100644 --- a/etc/NEWS +++ b/etc/NEWS @@ -102,12 +102,13 @@ effect should be negligible in the vast majority of cases anyway. By default, when you switch to another frame, an active minibuffer now moves to the newly selected frame. Nevertheless, the effect of what you type in the minibuffer happens in the frame where the minibuffer -was first activated, even if it moved to another frame. An -alternative behavior is available by customizing -'minibuffer-follows-selected-frame' to nil. Here, the minibuffer -stays in the frame where you first opened it, and you must switch back -to this frame to continue or abort its command. The old, somewhat -unsystematic behavior, which mixed these two is no longer available. +was first activated. An alternative behavior is available by +customizing 'minibuffer-follows-selected-frame' to nil. Here, the +minibuffer stays in the frame where you first opened it, and you must +switch back to this frame to continue or abort its command. The old +behavior, which mixed these two, can be approximated by customizing +'minibuffer-follows-selected-frame' to a value which is neither nil +nor t. +++ ** New system for displaying documentation for groups of functions. @@ -2046,6 +2047,12 @@ and display the result. When non-nil, then functions 'read-char-choice' and 'y-or-n-p' (respectively) use the function 'read-key' to read a character instead of using the minibuffer. ++++ +** New syntax flag 'e'. +This indicates that one or two (or more) escape characters escape a +comment ender with this flag, causing the comment to be continued past +that comment ender (typically onto the next line). + +++ ** 'set-window-configuration' now takes an optional 'dont-set-frame' parameter which, when non-nil, instructs the function not to select diff --git a/lisp/cus-start.el b/lisp/cus-start.el index 85dd14f628..0293d34d1c 100644 --- a/lisp/cus-start.el +++ b/lisp/cus-start.el @@ -394,7 +394,11 @@ minibuffer-prompt-properties--setter ;; (directory :format "%v")))) (load-prefer-newer lisp boolean "24.4") ;; minibuf.c - (minibuffer-follows-selected-frame minibuffer boolean "28.1") + (minibuffer-follows-selected-frame + minibuffer (choice (const :tag "Always" t) + (const :tag "When used" hybrid) + (const :tag "Never" nil)) + "28.1") (enable-recursive-minibuffers minibuffer boolean) (history-length minibuffer (choice (const :tag "Infinite" t) integer) diff --git a/lisp/window.el b/lisp/window.el index cd13e6603a..4b7d2c4677 100644 --- a/lisp/window.el +++ b/lisp/window.el @@ -4116,7 +4116,10 @@ window-deletable-p frame)) (throw 'other t)))) (let ((minibuf (active-minibuffer-window))) - (and minibuf (eq frame (window-frame minibuf))))) + (and minibuf (eq frame (window-frame minibuf)) + (not (eq (default-toplevel-value + minibuffer-follows-selected-frame) + t))))) 'frame)) ((window-minibuffer-p window) ;; If WINDOW is the minibuffer window of a non-minibuffer-only diff --git a/src/minibuf.c b/src/minibuf.c index 8b23569019..a99a208c2b 100644 --- a/src/minibuf.c +++ b/src/minibuf.c @@ -63,9 +63,30 @@ static Lisp_Object minibuf_prompt; static ptrdiff_t minibuf_prompt_width; +static Lisp_Object nth_minibuffer (EMACS_INT depth); + +/* Return TRUE when a frame switch causes a minibuffer on the old + frame to move onto the new one. */ static bool minibuf_follows_frame (void) +{ + return EQ (Fdefault_toplevel_value (Qminibuffer_follows_selected_frame), + Qt); +} + +/* Return TRUE when a minibuffer always remains on the frame where it + was first invoked. */ +static bool +minibuf_stays_put (void) +{ + return NILP (Fdefault_toplevel_value (Qminibuffer_follows_selected_frame)); +} + +/* Return TRUE when opening a (recursive) minibuffer causes + minibuffers on other frames to move to the selected frame. */ +static bool +minibuf_moves_frame_when_opened (void) { return !NILP (Fdefault_toplevel_value (Qminibuffer_follows_selected_frame)); } @@ -90,7 +111,7 @@ choose_minibuf_frame (void) minibuf_window = sf->minibuffer_window; /* If we've still got another minibuffer open, use its mini-window instead. */ - if (minibuf_level && !minibuf_follows_frame ()) + if (minibuf_level > 1 && minibuf_stays_put ()) { Lisp_Object buffer = get_minibuffer (minibuf_level); Lisp_Object tail, frame; @@ -105,26 +126,36 @@ choose_minibuf_frame (void) } } - if (minibuf_follows_frame ()) + if (minibuf_moves_frame_when_opened ()) /* Make sure no other frame has a minibuffer as its selected window, because the text would not be displayed in it, and that would be confusing. Only allow the selected frame to do this, and that only if the minibuffer is active. */ - { - Lisp_Object tail, frame; - - FOR_EACH_FRAME (tail, frame) - if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame)))) - && !(EQ (frame, selected_frame) - && minibuf_level > 0)) - Fset_frame_selected_window (frame, Fframe_first_window (frame), - Qnil); - } + { + Lisp_Object tail, frame; + struct frame *of; + + FOR_EACH_FRAME (tail, frame) + if (!EQ (frame, selected_frame) + && minibuf_level > 1) + { + of = XFRAME (frame); + if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (of)))) + Fset_frame_selected_window (frame, Fframe_first_window (frame), + Qnil); + + if (!EQ (XWINDOW (of->minibuffer_window)->contents, + nth_minibuffer (0))) + set_window_buffer (of->minibuffer_window, + nth_minibuffer (0), 0, 0); + } + } } -/* If `minibuffer_follows_selected_frame' and we have a minibuffer, move it - from its current frame to the selected frame. This function is - intended to be called from `do_switch_frame' in frame.c. */ +/* If `minibuffer_follows_selected_frame' is t and we have a + minibuffer, move it from its current frame to the selected frame. + This function is intended to be called from `do_switch_frame' in + frame.c. */ void move_minibuffer_onto_frame (void) { if (!minibuf_level) @@ -135,12 +166,15 @@ void move_minibuffer_onto_frame (void) && FRAME_LIVE_P (XFRAME (selected_frame)) && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window)) { + EMACS_INT i; struct frame *sf = XFRAME (selected_frame); Lisp_Object old_frame = XWINDOW (minibuf_window)->frame; struct frame *of = XFRAME (old_frame); - Lisp_Object buffer = XWINDOW (minibuf_window)->contents; - set_window_buffer (sf->minibuffer_window, buffer, 0, 0); + /* Stack up all the (recursively) open minibuffers on the selected + mini_window. */ + for (i = 1; i <= minibuf_level; i++) + set_window_buffer (sf->minibuffer_window, nth_minibuffer (i), 0, 0); minibuf_window = sf->minibuffer_window; set_window_buffer (of->minibuffer_window, get_minibuffer (0), 0, 0); } @@ -411,6 +445,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, Lisp_Object val; ptrdiff_t count = SPECPDL_INDEX (); Lisp_Object mini_frame, ambient_dir, minibuffer, input_method; + Lisp_Object calling_frame = selected_frame; Lisp_Object enable_multibyte; EMACS_INT pos = 0; /* String to add to the history. */ @@ -532,7 +567,9 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, minibuf_save_list = Fcons (Voverriding_local_map, Fcons (minibuf_window, - minibuf_save_list)); + Fcons (BVAR (XBUFFER (nth_minibuffer (minibuf_level - 1)), + keymap), + minibuf_save_list))); minibuf_save_list = Fcons (minibuf_prompt, Fcons (make_fixnum (minibuf_prompt_width), @@ -648,6 +685,17 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, } } + if (minibuf_moves_frame_when_opened ()) + { + EMACS_INT i; + + /* Stack up all the (recursively) open minibuffers on the selected + mini_window. */ + for (i = 1; i < minibuf_level; i++) + set_window_buffer (XFRAME (mini_frame)->minibuffer_window, + nth_minibuffer (i), 0, 0); + } + /* Display this minibuffer in the proper window. */ /* Use set_window_buffer instead of Fset_window_buffer (see discussion of bug#11984, bug#12025, bug#12026). */ @@ -727,8 +775,32 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, /* Don't allow the user to undo past this point. */ bset_undo_list (current_buffer, Qnil); + /* Prevent the user manipulating outer levels of recursive minibuffers. */ + if (minibuf_level > 1) + { + Lisp_Object inactive_map = + find_symbol_value (intern ("minibuffer-inactive-mode-map")); + if (!EQ (inactive_map, Qunbound)) + bset_keymap (XBUFFER (nth_minibuffer (minibuf_level - 1)), + inactive_map); + } + recursive_edit_1 (); + /* We've exited the recursive edit without an error, so switch the + current window away from the expired minibuffer window. */ + { + Lisp_Object prev = Fprevious_window (minibuf_window, Qnil, Qnil); + /* PREV can be on a different frame when we have a minibuffer only + frame, the other frame's minibuffer window is MINIBUF_WINDOW, + and its "focus window" is also MINIBUF_WINDOW. */ + while (!EQ (prev, minibuf_window) + && !EQ (selected_frame, WINDOW_FRAME (XWINDOW (prev)))) + prev = Fprevious_window (prev, Qnil, Qnil); + if (!EQ (prev, minibuf_window)) + Fset_frame_selected_window (selected_frame, prev, Qnil); + } + /* If cursor is on the minibuffer line, show the user we have exited by putting it in column 0. */ if (XWINDOW (minibuf_window)->cursor.vpos >= 0 @@ -767,6 +839,12 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, in set-window-configuration. */ unbind_to (count, Qnil); + /* Switch the frame back to the calling frame. */ + if (!EQ (selected_frame, calling_frame) + && FRAMEP (calling_frame) + && FRAME_LIVE_P (XFRAME (calling_frame))) + call2 (intern ("select-frame-set-input-focus"), calling_frame, Qnil); + /* Add the value to the appropriate history list, if any. This is done after the previous buffer has been made current again, in case the history variable is buffer-local. */ @@ -790,6 +868,14 @@ is_minibuffer (EMACS_INT depth, Lisp_Object buf) && EQ (Fcar (tail), buf); } +/* Return the DEPTHth minibuffer, or nil if such does not yet exist. */ +static Lisp_Object +nth_minibuffer (EMACS_INT depth) +{ + Lisp_Object tail = Fnthcdr (make_fixnum (depth), Vminibuffer_list); + return XCAR (tail); +} + /* Return a buffer to be used as the minibuffer at depth `depth'. depth = 0 is the lowest allowed argument, and that is the value used for nonrecursive minibuffer invocations. */ @@ -852,6 +938,7 @@ read_minibuf_unwind (void) Lisp_Object old_deactivate_mark; Lisp_Object window; Lisp_Object future_mini_window; + Lisp_Object map; /* If this was a recursive minibuffer, tie the minibuffer window back to the outer level minibuffer buffer. */ @@ -888,6 +975,8 @@ read_minibuf_unwind (void) #endif future_mini_window = Fcar (minibuf_save_list); minibuf_save_list = Fcdr (minibuf_save_list); + map = Fcar (minibuf_save_list); + minibuf_save_list = Fcdr (minibuf_save_list); /* Erase the minibuffer we were using at this level. */ { @@ -901,6 +990,10 @@ read_minibuf_unwind (void) unbind_to (count, Qnil); } + /* Restore the keymap of any outer level recursive minibuffer. */ + if (minibuf_level > 0) + bset_keymap (XBUFFER (nth_minibuffer (minibuf_level)), map); + /* When we get to the outmost level, make sure we resize the mini-window back to its normal size. */ if (minibuf_level == 0 @@ -2035,13 +2128,15 @@ For example, `eval-expression' uses this. */); The function is called with the arguments passed to `read-buffer'. */); Vread_buffer_function = Qnil; - DEFVAR_BOOL ("minibuffer-follows-selected-frame", minibuffer_follows_selected_frame, - doc: /* Non-nil means the active minibuffer always displays on the selected frame. + DEFVAR_LISP ("minibuffer-follows-selected-frame", minibuffer_follows_selected_frame, + doc: /* t means the active minibuffer always displays on the selected frame. Nil means that a minibuffer will appear only in the frame which created it. +Any other value means the minibuffer will move onto another frame, but +only when the user starts using a minniffer there. Any buffer local or dynamic binding of this variable is ignored. Only the default top level value is used. */); - minibuffer_follows_selected_frame = 1; + minibuffer_follows_selected_frame = Qt; DEFVAR_BOOL ("read-buffer-completion-ignore-case", read_buffer_completion_ignore_case, --KR1Ny43umX9KauN5--