vertico breaks mini-modeline

[QiangF]

mini-modeline is at https://github.com/kiennq/emacs-mini-modeline

Steps to reproduce

1. increase the font size, so that mini-modeline will take up more than one line the next step.

2. modify a buffer and exit emacs, to get the question: buffer modified save or not?

3. see, the minbuffer is not resized sometimes, because the window-resize in mini-modeline-display doesn't work.

    ;; log function
   
    (setq my-log-flag nil)
   
    (bind-key* (kbd "M-t") 'my-log-flag-toggle)
   
    (defun my-log-flag-toggle ()
      (interactive)
      (setq my-log-flag (not my-log-flag)))
   
    (defun my-log (&rest args)
      "Log message into message buffer with ARGS as same parameters in `message'."
      (when my-log-flag
        (save-excursion
          (with-current-buffer "*Messages*"
            (let ((inhibit-read-only t))
              (goto-char (point-max))
              (insert (apply #'format args)))))))
   
    ;; mini-modeline setup
   
    (setq mini-modeline-truncate-p nil) ;; so extra content will be displayed on another line
    (set vertico-resize 'grow-only)
   
    (defun mini-modeline-display (&optional arg)
      "Update mini-modeline.
    When ARG is:
    - `force', force update the minibuffer.
    - `clear', clear the minibuffer.  This implies `force'."
      (save-match-data
        (condition-case err
          (cl-letf (((symbol-function 'completion-all-completions) #'ignore)
                     (l-fmt mini-modeline-l-format)
                     (r-fmt mini-modeline-r-format))
            (unless (or (active-minibuffer-window)
                      (input-pending-p))
              (setq mini-modeline--minibuffer
                (window-buffer (minibuffer-window mini-modeline-frame)))
              (with-current-buffer mini-modeline--minibuffer
                (let ((truncate-lines mini-modeline-truncate-p)
                       (inhibit-read-only t)
                       (inhibit-redisplay t)
                       (buffer-undo-list t)
                       modeline-content)
                  (when (or (memq arg '(force clear))
                          (mini-modeline--overduep mini-modeline--last-update
                            mini-modeline-update-interval))
                    (when-let ((msg (or mini-modeline--msg-message (current-message))))
                      ;; Clear echo area and start new timer for echo message
                      ;; (mini-modeline--log "msg: %s\n" msg)
                      ;; (mini-modeline--log "from: %s\n" mini-modeline--msg-message)
                      (message nil)
                      (setq mini-modeline--last-echoed (current-time))
                      ;; we proritize the message from `message'
                      ;; or the message when we're not in middle of a command running.
                      (when (or mini-modeline--msg-message
                              (eq mini-modeline--command-state 'begin))
                        (setq mini-modeline--command-state 'exec)
                        ;; Don't echo keystrokes when in middle of command
                        (setq echo-keystrokes 0))
                      (setq mini-modeline--msg msg))
                    ;; Reset echo message when timeout and not in middle of command
                    (when (and mini-modeline--msg
                            (not (memq mini-modeline--command-state '(exec exec-read)))
                            (mini-modeline--overduep mini-modeline--last-echoed
                              mini-modeline-echo-duration))
                      (setq mini-modeline--msg nil))
                    ;; Showing mini-modeline
                    (if (eq arg 'clear)
                      (setq modeline-content nil)
                      (setq modeline-content
                        (pcase mini-modeline-echo-position
                          ("left"
                            (mini-modeline--multi-lr-render
                              (if mini-modeline--msg
                                (format-mode-line '(:eval (mini-modeline-msg)))
                                (format-mode-line l-fmt))
                              (format-mode-line r-fmt)))
                          ("middle"
                            (mini-modeline--multi-lr-render
                              (if mini-modeline--msg
                                (format-mode-line (append l-fmt '((:eval (mini-modeline-msg)))))
                                (format-mode-line l-fmt))
                              (format-mode-line r-fmt)))
                          ("right"
                            (mini-modeline--multi-lr-render
                              (format-mode-line l-fmt)
                              (if mini-modeline--msg
                                (format-mode-line '(:eval (mini-modeline-msg)))
                                (format-mode-line r-fmt))))))
                      (setq mini-modeline--last-update (current-time)))
   
                    ;; write to minibuffer
                    (unless (equal modeline-content
                              mini-modeline--cache)
                      (setq mini-modeline--cache modeline-content)
                      (erase-buffer)
                      (when mini-modeline--cache
                        (let ((height-delta (- (cdr mini-modeline--cache)
                                              (window-height (minibuffer-window mini-modeline-frame))))
                               ;; ; let mini-modeline take control of mini-buffer size
                               (resize-mini-windows t))
                          ;; @my-modification
                          (let* ((m-win (minibuffer-window mini-modeline-frame))
                                  (win-height (window-height m-win))
                                  (m-buffer (window-buffer m-win)))
                            (my-log "hd: %s, win-height %s \n" height-delta win-height))
   
                          (insert (car mini-modeline--cache))
   
                          (when (or (> height-delta 0)
                                  ;; this is to prevent window flashing for consecutive multi-line message
                                  (mini-modeline--overduep mini-modeline--last-change-size
                                    mini-modeline-echo-duration))
                            ;; (vertico--resize-window (cdr mini-modeline--cache))
                            (window-resize (minibuffer-window mini-modeline-frame) height-delta)
                            (setq mini-modeline--last-change-size (current-time))
   
                            ;; @my-modification
                            (let* ((m-win (minibuffer-window mini-modeline-frame))
                                    (win-height (window-height m-win))
                                    (m-buffer (window-buffer m-win)))
                              (my-log "hd: %s, win-height %s\n" height-delta win-height)))
                          (insert (car mini-modeline--cache))))))))))
          ((error debug)
            (mini-modeline--log "mini-modeline: %s\n" err)))))
   

[minad]

Hi, thanks for the report. Special support for packages which heavily modify the minibuffer or the echo area is out of scope of Vertico. If you have a simple patch, which makes this work, I am open to it. However the question remains if the fix should be here or in mini-modeline.