Como alternar a exibição de imagens em eww sem atualizar a página?

Eu uso o eww para navegar na Internet e, na maioria das vezes, não quero que as imagens sejam carregadas, não parece haver muito em termos de personalizações incorporadas ao eww e nenhuma que lide com imagens.

Atualmente, tenho uma configuração do sistema que permite iniciar e parar a exibição de imagens no eww, mas somente após a atualização da página, o que eu quero é uma maneira de ativar e desativar as imagens sem atualizar a página .

Aqui está o meu método atual que tira proveito dos elementos internos dos shr-put-imagequais o eww usa.

(defvar display-graphic-override nil
  "Used to override `display-graphic-p' behavior.
Should either be nil, or a list where the car is the override.")

(defadvice display-graphic-p (around sometimes-lie activate)
  "Use the override if it is non nil."
  (if display-graphic-override
      (car display-graphic-override)
    ad-do-it))

(defadvice eww-render (around no-images activate)
  "Temporarily lie about supporting graphics"
  (let ((display-graphic-override '(nil)))
    ad-do-it))

Também tentei alternar a propriedade 'texto invisível onde estão as imagens, mas isso não parece funcionar.

fundo

Eww, como muitos outros pacotes, usa a displaypropriedade text para exibir imagens. É por isso que alternar a invisiblepropriedade de texto não ajudou. Você está tornando o texto invisível, mas a display propriedade ainda está sendo exibida.

De fato, isso é algo tão comum que o código abaixo deve funcionar em qualquer buffer que exiba imagens (não apenas eww).

Solução

A solução mais fácil é apenas remover a displaypropriedade de todo o buffer. Mas essa é uma ação irreversível, você não seria capaz de ativar as imagens novamente sem atualizar a página.

A solução mais robusta, apresentada abaixo, remove display propriedades no buffer e faz o backup simultâneo da imagem em outra propriedade (inútil). Quando chamado novamente, o comando move as imagens de backup de volta para a displaypropriedade.

(defvar-local endless/display-images t)

(defun endless/toggle-image-display ()
  "Toggle images display on current buffer."
  (interactive)
  (setq endless/display-images
        (null endless/display-images))
  (endless/backup-display-property endless/display-images))

Esse é o cara que faz o backup e a restauração em qualquer lugar. O código de propriedade do texto não é muito fácil de ler, mas acho que essa função é curta o suficiente para ser autoexplicativa.

(defun endless/backup-display-property (invert &optional object)
  "Move the 'display property at POS to 'display-backup.
Only applies if display property is an image.
If INVERT is non-nil, move from 'display-backup to 'display
instead.
Optional OBJECT specifies the string or buffer. Nil means current
buffer."
  (let* ((inhibit-read-only t)
         (from (if invert 'display-backup 'display))
         (to (if invert 'display 'display-backup))
         (pos (point-min))
         left prop)
    (while (and pos (/= pos (point-max)))
      (if (get-text-property pos from object)
          (setq left pos)
        (setq left (next-single-property-change pos from object)))
      (if (or (null left) (= left (point-max)))
          (setq pos nil)
        (setq prop (get-text-property left from object))
        (setq pos (or (next-single-property-change left from object)
                      (point-max)))
        (when (eq (car prop) 'image)
          (add-text-properties left pos (list from nil to prop) object))))))

Por favor, deixe-me saber se funciona! Eu só testei em páginas da web muito simples.

No Emacs 25.1, você pode passar um argumento eww-reloadpara carregar do cache em vez da rede. Estou usando o seguinte:

(defun my/eww-toggle-images ()
  "Toggle whether images are loaded and reload the current page fro cache."
  (interactive)
  (setq-local shr-inhibit-images (not shr-inhibit-images))
  (eww-reload t)
  (message "Images are now %s"
           (if shr-inhibit-images "off" "on")))

(define-key eww-mode-map (kbd "I") #'my/eww-toggle-images)
(define-key eww-link-keymap (kbd "I") #'my/eww-toggle-images)

;; minimal rendering by default
(setq-default shr-inhibit-images t)   ; toggle with `I`
(setq-default shr-use-fonts nil)      ; toggle with `F`

Isso desabilita imagens e fontes proporcionais por padrão. A alternância de fontes está vinculada Fpor padrão, por isso estou usando Ipara alternar imagens. (Isso substitui uma ligação padrão para shr-insert-image, mas eu nunca a usei.)