Faça uma função para alternar temas

Como eu poderia criar uma função interativa para alternar entre dois temas de cores?

Pelo que pude descobrir, não há uma variável definida para o tema de cores atualmente em uso. De fato, várias podem ser carregadas simultaneamente?

Além disso, para alternar, você precisa primeiro fazer disable-themeo tema atualmente carregado, para não fazer com que os temas não se choquem.

Como fazer isso sem saber qual tema está carregado no momento?

Eu fiz isso, mas troco 3 temas (meu próprio kosmos, Lovaina e padrão)

Você pode verificar https://github.com/habamax/.emacs.d/blob/master/lisp/haba-appearance.el

excerto:

(defvar *haba-theme-dark* 'kosmos)
(defvar *haba-theme-light* 'leuven)
(defvar *haba-current-theme* *haba-theme-dark*)

;; disable other themes before loading new one
(defadvice load-theme (before theme-dont-propagate activate)
  "Disable theme before loading new one."
  (mapcar #'disable-theme custom-enabled-themes))


(defun haba/next-theme (theme)
  (if (eq theme 'default)
      (disable-theme *haba-current-theme*)
    (progn
      (load-theme theme t)))
  (setq *haba-current-theme* theme))

(defun haba/toggle-theme ()
  (interactive)
  (cond ((eq *haba-current-theme* *haba-theme-dark*) (haba/next-theme *haba-theme-light*))
        ((eq *haba-current-theme* *haba-theme-light*) (haba/next-theme 'default))
        ((eq *haba-current-theme* 'default) (haba/next-theme *haba-theme-dark*))))

Em seguida, vincule alguma chave ao haba / toggle-theme.

Eu uso o emacs em 2 máquinas e ambientes diferentes (dia e noite), para que haja facilidade para salvar / restaurar o tema atual no qumac / load emacs. O que é útil :)

Escrevi algumas funções para percorrer um grupo de temas.

(setq ivan/themes '(elixir elixir-dark))
(setq ivan/themes-index 0)

(defun ivan/cycle-theme ()
  (interactive)
  (setq ivan/themes-index (% (1+ ivan/themes-index) (length ivan/themes)))
  (ivan/load-indexed-theme))

(defun ivan/load-indexed-theme ()
  (ivan/try-load-theme (nth ivan/themes-index ivan/themes)))

(defun ivan/try-load-theme (theme)
  (if (ignore-errors (load-theme theme :no-confirm))
      (mapcar #'disable-theme (remove theme custom-enabled-themes))
    (message "Unable to find theme file for ‘%s’" theme)))

Eu chamo ivan/load-indexed-themeno meu arquivo init para inicializar o meu tema.

Eu ligo ivan/cycle-themepara Space\no modo mal. ( Spaceé a chave do meu líder.)

Embora as respostas existentes funcionem bem, gostaria de compartilhar uma mais simples:

(defun toggle-theme ()
  (interactive)
  (if (eq (car custom-enabled-themes) 'leuven)
      (disable-theme 'leuven)
    (enable-theme 'leuven)))
(global-set-key [f5] 'toggle-theme)

Isso não desativa o tema personalizado padrão primeiro, mas eu gosto disso.

Este é o módulo que escrevi para o meu .emacs para resolver esse problema. Minha abordagem básica parece ser semelhante na intenção da solução de Maxim Kim (alternando entre uma lista de temas), mas acho que a minha é mais modular e, portanto, pode ser mais acessível a quem está de fora. Por outro lado, não tenho nenhum dos recursos de persistência de Kim.

Aqui está o código relevante, excluindo declarações de variáveis ​​e comentários de pacotes:

(require 'dash)

(defun multitheme--enable (theme)
  "As `enable-theme', but load the theme if necessary.
Respect `custom-safe-themes'."
  (if (custom-theme-p theme)
      (enable-theme theme)
    (load-theme theme)))

(defun multitheme-cycle ()
  "Cycle between the themes in `multitheme-base-theme-list'.
If none of these themes is currently active, instead enable the
first element of `multitheme-base-theme-list'.

Also re-enable `multitheme-overtheme' so it remains \"on top\" of
the base theme.

If a theme to be enabled is not yet defined, attempt to load it
first (using `load-theme').  Respect `custom-safe-themes'.

After all theme changes have been made, run
`multitheme-base-change-hook'."
  (interactive)
  (when (require 'validate nil :noerror)
    (validate-variable 'multitheme-base-theme-list)
    (validate-variable 'multitheme-overtheme)
    (validate-variable 'multitheme-base-theme-change-hook))
  (let ((themes (-drop-while
                 (lambda (thm) (not (custom-theme-enabled-p thm)))
                 multitheme-base-theme-list)))
    ;; Cycle base theme
    (if (null themes)
        (multitheme--enable (car multitheme-base-theme-list))
      (disable-theme (car themes))
      (multitheme--enable (or (cadr themes)
                              (car multitheme-base-theme-list))))
    ;; Reassert overtheme
    (when multitheme-overtheme
      (multitheme--enable multitheme-overtheme))
    ;; Run hooks
    (run-hooks 'multitheme-base-theme-change-hook)))

Eu tenho esta configuração para temas de ciclismo:

(defvar quick-switch-themes
  (let ((themes-list (list 'jazz
                           ;; 'vicarie-and-blackboard
                           ;; 'tangotango
                           'poet)))
    (nconc themes-list themes-list))
  "A circular list of themes to keep switching between.
Make sure that the currently enabled theme is at the head of this
list always.

A nil value implies no custom theme should be enabled.")

(defun quick-switch-themes* ()
  "Switch between to commonly used faces in Emacs.
One for writing code and the other for reading articles."
  (interactive)
  (if-let* ((next-theme (cadr quick-switch-themes)))
      (progn (when-let* ((current-theme (car quick-switch-themes)))
               (disable-theme (car quick-switch-themes)))
             (load-theme next-theme t)
             (message "Loaded theme: %s" next-theme))
    ;; Always have the dark mode-line theme
    (mapc #'disable-theme (delq 'smart-mode-line-dark custom-enabled-themes)))
  (setq quick-switch-themes (cdr quick-switch-themes)))

Sei que estou um pouco atrasado para a festa, mas criei um pacote para fazer exatamente isso e muito mais.

Basicamente, você pode definir uma lista dos seus temas de cores favoritos (que são opcionais) e percorrer a lista de maneira conveniente.