Cambia la faccia mode-line-buffer-id per le finestre inattive

Esiste una faccia Emacs che può essere usata per controllare il colore dei nomi dei buffer inattivi?

Normalmente quando si imposta la faccia mode-line-buffer-idsono interessate tutte le finestre.

In questo esempio mode-lineha uno sfondo chiaro, quindi ho impostato mode-line-buffer-iduno molto più scuro #333.

L'idea è di invertire la combinazione di colori per mode-line-inactive.

Sebbene ciò sia possibile per la maggior parte del testo nella riga di modalità delle finestre inattive, i nomi dei buffer diventano illeggibili poiché sono ancora controllati dalla mode-line-buffer-idfaccia.

Ritengo che l'impostazione mode-line-inactivesu uno sfondo più chiaro aggirerebbe il problema, ma non è questo il risultato che desidero ottenere.

Non sono sicuro se stai ancora cercando una risposta o no, ma questo è stato l'unico risultato che ho ottenuto su Google mentre provavo a farlo da solo.

Ad ogni modo, per qualsiasi motivo, Emacs lo chiama distant-foregroundcosì l'unica cosa che devi davvero fare è aggiungere :distant-foreground $colour-of-choiceal tuo viso.

Ecco una variazione su un'altra risposta che potrebbe aiutare. Questo esempio si riassume mode-line-buffer-idcome verde nei buffer inattivi.

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

Aggiornamento: come notato nei commenti, questo non risolve completamente il problema. Quando hai più finestre visibili che visitano lo stesso buffer, condivideranno tutte la stessa faccia.

Questa è una variazione delle altre risposte, con questa che distingue tra finestre attive e inattive. Se un buffer è visibile in più di una finestra, solo la finestra attiva avrà ml-active-window-facee tutte le altre finestre avranno 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")))

Non sono sicuro che sia possibile. Sembra che la riga della modalità sia aggiornata solo quando è selezionata la sua finestra (test usando le chiamate per messageconfermarlo). E il codice che fa questo è il codice C, non Lisp.

È possibile utilizzare un'espressione condizionale nella definizione di mode-line-buffer-identification, in modo che la faccia da utilizzare venga calcolata in modo dinamico. Ma non conosco alcuna funzione o variabile che è possibile utilizzare per verificare se una determinata finestra ha una linea di modalità inattiva.

Non è possibile utilizzare selected-window, ad esempio, perché punta sempre alla finestra con la linea di modalità attiva.

Ecco un esempio di aggiornamento dinamico basato sul nome del buffer. Non è quello che vuoi, ma almeno ti mostra cosa puoi fare. Se riesci a trovare un modo per verificare se la finestra da aggiornare è selezionata, puoi sostituirla con il test del nome del buffer. (Ma la mia impressione è che solo la finestra selezionata ottiene la sua linea di modalità aggiornata.)

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

Un'altra cosa che potresti provare è consigliare la funzione format-mode-line. Apparentemente distingue una finestra con una linea di modalità attiva da una con una linea di modalità inattiva. Ma anche questo è codificato in C, quindi dubito che andrai molto lontano nel consigliarlo. Qmode_line_inactiveVerifica la variabile C , FWIW.

Suggerirei di porre questa domanda su una delle mailing list di Emacs (ad esempio help-gnu-emacs@gnu.org), se non ottieni una risposta soddisfacente qui. Sembra che potrebbe essere bello poter fare ciò che richiedi. +1 per la domanda, in ogni caso.