Cambiar la cara de mode-line-buffer-id para ventanas inactivas

¿Hay una cara de Emacs que se pueda usar para controlar el color de los nombres de búfer inactivos?

Normalmente, al configurar la cara, mode-line-buffer-idtodas las ventanas se ven afectadas.

En este ejemplo, mode-linetiene un fondo claro, por lo que configuré mode-line-buffer-idun fondo mucho más oscuro #333.

La idea es invertir la combinación de colores para mode-line-inactive.

Si bien esto es posible para la mayoría del texto en la línea de modo de las ventanas inactivas, los nombres de los búferes se vuelven ilegibles ya que todavía está controlado por la mode-line-buffer-idcara.

Creo que establecer mode-line-inactiveun fondo más claro solucionaría el problema, pero ese no es el resultado que deseo lograr.

No estoy seguro de si todavía estás buscando una respuesta o no, pero este fue el único resultado que obtuve en Google al intentar hacerlo yo mismo.

De todos modos, por cualquier razón, Emacs lo llama distant-foregroundasí que lo único que realmente necesita hacer es agregar :distant-foreground $colour-of-choicea su cara.

Aquí hay una variación de otra respuesta que podría ayudar. Este ejemplo se reasigna mode-line-buffer-idpara ser verde en buffers inactivos.

(defun toggle-mode-line-buffer-id-face (window)
  "Update the `mode-line-buffer-id' face in WINDOW dependening on
whether the window is selected."
  (with-current-buffer (window-buffer window)
(if (eq (current-buffer) (window-buffer (selected-window)))
    (face-remap-reset-base 'mode-line-buffer-id)
  (face-remap-set-base 'mode-line-buffer-id '(:foreground "green")))))

(add-hook 'buffer-list-update-hook (lambda () (walk-windows #'toggle-mode-line-buffer-id-face nil t)))

Actualización: como se señaló en los comentarios, esto no resuelve completamente el problema. Cuando tiene varias ventanas visibles visitando el mismo búfer, todas compartirán la misma cara.

Esta es una variación de las otras respuestas, y esta distingue entre ventanas activas e inactivas. Si un búfer es visible en más de una ventana, solo la ventana activa tendrá ml-active-window-facey todas las demás ventanas tendrán ml-inactive-window-face.

(defvar ml-selected-window nil)

(defun ml-record-selected-window ()
  (setq ml-selected-window (selected-window)))

(defun ml-update-all ()
  (force-mode-line-update t))

(add-hook 'post-command-hook 'ml-record-selected-window)

(add-hook 'buffer-list-update-hook 'ml-update-all)

(defface ml-active-window-face
   '((t (:foreground "red")))
   "Face for active buffer identification.")

(defface ml-inactive-window-face
   '((t (:foreground "green")))
   "Face for inactive buffer identification.")

(defun ml-propertized-buffer-identification (fmt)
  "Return a list suitable for `mode-line-buffer-identification'.
FMT is a format specifier such as \"%12b\".  This function adds
text properties for face, help-echo, and local-map to it."
  (list (propertize fmt
        'face
          (if (eq ml-selected-window (selected-window))
            'ml-active-window-face
            'ml-inactive-window-face)
        'help-echo
        (purecopy "Buffer name
mouse-1: Previous buffer\nmouse-3: Next buffer")
        'mouse-face 'mode-line-highlight
        'local-map mode-line-buffer-identification-keymap)))

(setq-default mode-line-buffer-identification
  '(:eval (ml-propertized-buffer-identification "%12b")))

No estoy seguro de que sea posible. Parece que la línea de modo se actualiza solo cuando se selecciona su ventana (la prueba con llamadas lo messageconfirma). Y el código que hace esto es el código C, no Lisp.

Puede usar una expresión condicional en la definición de mode-line-buffer-identification, para que la cara a usar se calcule dinámicamente. Pero no conozco ninguna función o variable que pueda usar para probar si una ventana dada tiene una línea de modo inactiva.

No puede usar selected-window, por ejemplo, porque eso siempre apunta a la ventana con la línea de modo activa.

Aquí hay un ejemplo de actualización dinámica que se basa en el nombre del búfer. No es lo que quieres, pero al menos te muestra lo que puedes hacer. Si puede encontrar una manera de probar si la ventana que se está actualizando está seleccionada, entonces puede sustituirla por la prueba de nombre de búfer. (Pero mi impresión es que solo la ventana seleccionada obtiene su línea de modo actualizada).

(setq-default mode-line-buffer-identification
              '(:eval
                (list (propertize "%b"
                       'face (if ;; NOPE (eq (selected-window) (get-buffer-window (current-buffer)))
                                 (eq (current-buffer) (get-buffer "some-buffer"))
                                 'mode-line-buffer-id
                               'some-other-face)
                       'help-echo "Buffer name mouse-1: Previous buffer\nmouse-3: Next buffer"
                       'mouse-face 'mode-line-highlight
                       'local-map mode-line-buffer-identification-keymap))))

Otra cosa que puedes probar es aconsejar la función format-mode-line. Aparentemente distingue una ventana con una línea de modo activa de una con una línea de modo inactiva. Pero también está codificado en C, por lo que dudo que llegue muy lejos al aconsejarlo. Prueba la variable C Qmode_line_inactive, FWIW.

Sugeriría hacer esta pregunta en una de las listas de correo de Emacs (por ejemplo [email protected]), si no obtiene una respuesta satisfactoria aquí. Parece que podría ser bueno poder hacer lo que usted solicita. +1 para la pregunta, en cualquier caso.