Nascondi l'elenco delle modalità secondarie nella riga di modalità

Uso parecchie modalità secondarie e di solito so quale modalità minore è abilitata in tutte le modalità principali. Se voglio davvero vedere l'elenco completo, posso correre C-h v minor-mode-list.

Allo stesso tempo, la mia linea di modalità si ostruisce davvero, quindi quando divido verticalmente il frame, a volte non riesco a leggere la fine della linea di modalità.

Domanda effettiva: come disabilitare la visualizzazione dell'elenco delle modalità secondarie nella riga della modalità? Ad esempio, ora potrebbe apparire così:

-:--- main.c        All (7,12)     (C/l FlyC SScr Abbrev Fill) [main] 16:19 0.45

Voglio che appaia più conciso:

-:--- main.c        All (7,12)     (C/l) [main] 16:19

La modalità Diminish (disponibile in Melpa) lo farà.

(diminish 'projectile-mode)

Come ha commentato mbork, puoi usare delight.el per modificare o disabilitare selettivamente il testo in modalità minore (e in effetti maggiore) nella riga della modalità.

Uno dei vantaggi è che si prende cura di eval-after-load(che è necessario scrivere manualmente con dimin.el nella maggior parte dei casi d'uso), il che rende la configurazione più pulita. Hai ancora bisogno delle stesse informazioni - il nome della modalità e la libreria che la implementa (cosa che Emacs ti dirà se le chiedi sulla modalità) - ma puoi racchiuderle tutte in un unico modulo:

 (require 'delight)
 (delight '((some-mode nil "some-library")
            (some-other-mode nil "some-other-library")))

(Oppure segui il link sopra per alcuni esempi di utilizzo reale.)

Consiglio di prendere questo approccio, perché anche se non si vuole più il testo più chiaro modo minore, c'è una buona probabilità che troverete alcuni di loro utili (ed è ancora possibile modificare quelli ad essere più brevi).

Se vuoi veramente eliminare tutto il testo più leggero in modalità minore (e ancora, non lo consiglio), puoi modificare la mode-line-modesvariabile. Le variabili della linea di modalità sono cambiate qualche tempo fa, quindi potresti voler usare M-x find-variable RET mode-line-modes RETe quindi adattare manualmente la tua definizione predefinita, modificando la sezione relativa minor-modes-alist.

Ovviamente allora dovresti mantenerlo, che non è così flash, quindi potresti preferire la sostituzione del minor-mode-alistsimbolo all'interno del valore esistente. Quanto segue è in qualche modo specifico per l'implementazione, ma sicuramente più bello dell'impostazione mode-line-modesnella sua interezza e puoi attivarlo e disattivarlo.

(define-minor-mode minor-mode-blackout-mode
  "Hides minor modes from the mode line."
  t)

(catch 'done
  (mapc (lambda (x)
          (when (and (consp x)
                     (equal (cadr x) '("" minor-mode-alist)))
            (let ((original (copy-sequence x)))
              (setcar x 'minor-mode-blackout-mode)
              (setcdr x (list "" original)))
            (throw 'done t)))
        mode-line-modes))

(global-set-key (kbd "C-c m") 'minor-mode-blackout-mode)

Usa Rich-minority con config:

(require 'rich-minority)
(rich-minority-mode 1)
(setf rm-blacklist "")

Anch'io ho il pensiero come te, ma accorcio la linea di modalità più paranoica :

• Rimuovi tutti gli spazi indesiderati
• Rimuovere tutti gli spazi e la "larghezza minima" del campo informazioni sulla posizione del buffer.

;; Remove all unwanted spaces
(setq-default mode-line-format
          '("%e" mode-line-front-space mode-line-mule-info mode-line-client mode-line-modified mode-line-remote mode-line-buffer-identification mode-line-position
        (vc-mode vc-mode) " "
        mode-line-modes mode-line-misc-info mode-line-end-spaces))
;; Remove all spaces and "min-width" of position info on mode-line
(setq mode-line-position
      `((1 ,(propertize
         " %p"
         'local-map mode-line-column-line-number-mode-map
         'mouse-face 'mode-line-highlight
         ;; XXX needs better description
         'help-echo "Size indication mode\n\
mouse-1: Display Line and Column Mode Menu"))
    (size-indication-mode
     (2 ,(propertize
          "/%I"
          'local-map mode-line-column-line-number-mode-map
          'mouse-face 'mode-line-highlight
          ;; XXX needs better description
          'help-echo "Size indication mode\n\
mouse-1: Display Line and Column Mode Menu")))
    (line-number-mode
     ((column-number-mode
       (1 ,(propertize
        "(%l,%c)"
        'local-map mode-line-column-line-number-mode-map
        'mouse-face 'mode-line-highlight
        'help-echo "Line number and Column number\n\
mouse-1: Display Line and Column Mode Menu"))
       (1 ,(propertize
        "L%l"
        'local-map mode-line-column-line-number-mode-map
        'mouse-face 'mode-line-highlight
        'help-echo "Line Number\n\
mouse-1: Display Line and Column Mode Menu"))))
     ((column-number-mode
       (1 ,(propertize
        "C%c"
        'local-map mode-line-column-line-number-mode-map
        'mouse-face 'mode-line-highlight
        'help-echo "Column number\n\
mouse-1: Display Line and Column Mode Menu"))))))
      )

Ora, posso sempre vedere la notifica in modalità Twitter e il timer in modalità Org: D

Ecco cosa ha funzionato per me:

(defvar hidden-minor-modes ; example, write your own list of hidden
  '(abbrev-mode            ; minor modes
    auto-fill-function
    flycheck-mode
    flyspell-mode
    inf-haskell-mode
    haskell-indent-mode
    haskell-doc-mode
    smooth-scroll-mode))

(defun purge-minor-modes ()
  (interactive)
  (dolist (x hidden-minor-modes nil)
    (let ((trg (cdr (assoc x minor-mode-alist))))
      (when trg
        (setcar trg "")))))

(add-hook 'after-change-major-mode-hook 'purge-minor-modes)

Grazie al commento di Drew , ho migliorato la realizzazione di questa soluzione. Ora utilizza i vantaggi degli elenchi di associazioni e dovrebbe essere un po 'più efficiente ;-)

Getterò la mia soluzione anche sul ring:

(defun modeline-set-lighter (minor-mode lighter)
  (when (assq minor-mode minor-mode-alist)
    (setcar (cdr (assq minor-mode minor-mode-alist)) lighter)))

(defun modeline-remove-lighter (minor-mode)
  (modeline-set-lighter minor-mode ""))

modeline-set-lighterti permette di impostare l'accendino di una modalità minore su qualsiasi stringa che ti piace. modeline-remove-lighterconsente di rimuovere completamente l'accendino di una modalità minore.

Quindi, alla fine del mio file init, chiamo solo queste funzioni per le modalità secondarie di cui voglio modificare gli accendini:

(modeline-remove-lighter 'auto-complete-mode)
(modeline-remove-lighter 'git-gutter+-mode)
(modeline-remove-lighter 'guide-key-mode)
(modeline-remove-lighter 'whitespace-mode)
(modeline-set-lighter 'abbrev-mode " Abbr")
(modeline-set-lighter 'auto-fill-function (string 32 #x23ce))

Puoi anche rimuovere senza mezzi termini tutte le modalità minori, nel modo seguente:

(setq mode-line-modes
      (mapcar (lambda (elem)
                (pcase elem
                  (`(:propertize (,_ minor-mode-alist . ,_) . ,_)
                   "")
                  (t elem)))
              mode-line-modes))

Questo funzionerà anche per le modalità secondarie definite in futuro, poiché rimuove completamente l'uso di minor-mode-alistda mode-line-format.

Vale la pena notare che use-package supporta diminuisce e delizia . Se lo usi per gestire i tuoi pacchetti, puoi nascondere le modalità secondarie nella riga delle modalità aggiungendo le parole chiave: diminuisci o: delizia.

(use-package abbrev
  :diminish abbrev-mode
  :config
  (if (file-exists-p abbrev-file-name)
     (quietly-read-abbrev-file)))

Non vedo il punto di installare fantasiose estensioni con nome per qualcosa di semplice come:

(setcar (alist-get minor-mode minor-mode-alist) "")

Per esempio:

(dolist (mode '(projectile-mode
                whitespace-mode
                hs-minor-mode
                outline-minor-mode
                auto-fill-function))
  (setcar (alist-get mode minor-mode-alist) ""))

Puoi fare qualsiasi cosa in questo modo. La sostituzione del testo è ovvia da quanto sopra. Inoltre, ad esempio, per mettere la modalità flymake all'inizio dell'elenco:

(let ((mode (assq #'flymake-mode minor-mode-alist)))
  (setq minor-mode-alist (cons mode (remq mode minor-mode-alist))))