enfatizar o erro atual na janela * compilação *

Ao executar o comando compile e pular para o 'próximo erro', o emacs identifica a linha do erro atual colocando um pequeno triângulo preto, apontando para a direita, na margem esquerda do buffer * compilation * . Isso é legal, mas meus velhos olhos gostariam de um indicador mais ousado. O objetivo fundamental aqui é ser capaz de identificar rapidamente visualmente qual linha o emacs está identificando como o erro atual do compilador. Algumas soluções que vêm à mente:

1. uma face diferente para o erro atual (maior por exemplo).
2. uma cor de fundo diferente para o erro atual (algo como modo hl-linha).
3. um triângulo maior.

mas também estou aberto a outras idéias.

Alguém pode me ajudar?

Eu queria conseguir a mesma coisa, pois muitas vezes era doloroso encontrar a mensagem de erro atual no buffer de compilação. Esta solução é baseada na sugestão de Drew de usar a next-error-hookpara destacar a mensagem de erro. Atualmente, apenas destaca a primeira linha da mensagem de erro, mas acho que isso é bom o suficiente.

(defcustom next-error-message-highlight-p nil
  "If non-nil, highlight the current error message in the ‘next-error’ buffer"
  :type 'boolean
  :group 'next-error
  :version "??")

(defface next-error-message
  '((t (:inherit highlight)))
  "Face used to highlight the current error message in the ‘next-error’ buffer"
  :group 'next-error
  :version "??")

(defvar next-error-message-highlight-overlay
  nil
  "Overlay highlighting the current error message in the ‘next-error’ buffer")

(make-variable-buffer-local 'next-error-message-highlight-overlay)

(defun next-error-message-highlight ()
  "Highlight the current error message in the ‘next-error’ buffer."
  (when next-error-message-highlight-p
    (with-current-buffer next-error-last-buffer
      (when next-error-message-highlight-overlay
        (delete-overlay next-error-message-highlight-overlay))
      (save-excursion
        (goto-char (point))
        (let ((ol (make-overlay (line-beginning-position) (line-end-position))))
          ;; do not override region highlighting
          (overlay-put ol 'priority -50)
          (overlay-put ol 'face 'next-error-message)
          (overlay-put ol 'window (get-buffer-window))
          (setf next-error-message-highlight-overlay ol))))))

(add-hook 'next-error-hook 'next-error-message-highlight)

Uso:

(setq next-error-message-highlight-p t)

Demo:

Aqui está um exemplo de como modificar a imagem de bitmap que aparece na margem esquerda do *compilation*buffer (por exemplo, o *grep*buffer de resultados):

(define-fringe-bitmap 'custom-right-arrow [128 192 96 48 24 48 96 192 128] 9 8 'center)

(put 'overlay-arrow-position 'overlay-arrow-bitmap 'custom-right-arrow)

Aqui está um exemplo de como definir as cores dos bitmaps adicionais:

(defface right-triangle-face
  '((t (:background "red" :foreground "yellow")))
  "Face for `right-triangle-face`.")

(set-fringe-bitmap-face 'right-triangle 'right-triangle-face)

Aqui está um exemplo de como criar seu próprio bitmap adicional:

;; AUTHOR:  Nikolaj Schumacher -- https://github.com/nschum/fringe-helper.el
;;
(defun fringe-helper-convert (&rest strings)
"Convert STRINGS into a vector usable for `define-fringe-bitmap'.
Each string in STRINGS represents a line of the fringe bitmap.
Periods (.) are background-colored pixel; Xs are foreground-colored. The
fringe bitmap always is aligned to the right. If the fringe has half
width, only the left 4 pixels of an 8 pixel bitmap will be shown.
For example, the following code defines a diagonal line.
\(fringe-helper-convert
\"XX......\"
\"..XX....\"
\"....XX..\"
\"......XX\"\)"
  (unless (cdr strings)
  ;; only one string, probably with newlines
    (setq strings (split-string (car strings) "\n")))
  (apply 'vector
    (mapcar
      (lambda (str)
        (let ((num 0))
          (dolist (c (string-to-list str))
            (setq num (+ (* num 2) (if (eq c ?.) 0 1))))
          num))
      strings)))

(define-fringe-bitmap 'backslash (fringe-helper-convert
  "XX......"
  "XX......"
  " XX....."
  ".XX....."
  "..XX...."
  "..XX...."
  "...XX..."
  "...XX..."
  "....XX.."
  "....XX.."
  ".....XX."
  ".....XX.") nil nil 'center)

Não next-errorrola o buffer de erros de compilação, para que o erro atual seja exibido como a primeira linha da janela?

Caso contrário, ele não coloca o cursor na linha de erro atual? Se houver, e se o cursor não estiver visível o suficiente para você, considere usar hl-line-modepara destacar a linha atual. Ou considere usar a biblioteca crosshairspara destacar a linha atual e a coluna atual.

Atualize após o seu comentário

Eu pensei que você estava invocando next-errorno buffer *compilation*. Se você fizer isso, a linha será rolada para o topo, como descrevi.

Mas se você estiver chamando o next-errorbuffer externo *compilation*, precisará usar next-error-hook, no buffer*compilation* , a linha ou a franja atual ou o que for, da maneira que desejar.

Aqui está um exemplo rápido e sujo:

(defun foo ()
  "..."
  (with-current-buffer next-error-last-buffer
    (hl-line-mode 1)))

(add-hook 'next-error-hook 'foo)

(Claro, você realmente só precisa de ligar hl-line-modeuma vez em que buffer. Fazê-lo como mostrado acima é um exagero, mas não faz mal. Você pode pensar que você poderia apenas adicionar fooao grep-mode-hookou compilation-mode-hook. Mas quando esses ganchos são invocados existe não next-error-last-buffer.)

Nota:

1. Existem duas opções de usuário que controlam as maneiras de indicar a ocorrência no buffer de origem (não no buffer de compilação): next-error-highlighte next-error-highlight-no-select. Eles oferecem as mesmas possibilidades, mas são usados ​​por comandos diferentes. As possibilidades incluem usar uma seta de franja ou destacar a partida por um certo tempo.

2. Mas não existe essa opção controlando a indicação da ocorrência atual no buffer *compilation*. Portanto, o Emacs oferece duas opções (onde provavelmente seria suficiente) para o buffer de origem, mas nenhuma opção para o buffer de compilação.

Você pode considerar a apresentação de uma solicitação de melhoria, para obter uma opção semelhante para a compilação (incluindo grep) buffer: M-x report-emacs-bug. Usar um gancho com sua própria função para realizar o realce é bom, mas não deve ser necessário.

E se você quiser apenas alterar o indicador de franja, você pode fazer isso (use o bitmap de franja desejado, em vez de filled-rectangle- consulte (elisp) Bitmaps de franja para obter uma lista dos predefinidos):

(defun bar ()
  (with-current-buffer next-error-last-buffer
    (unless (eq 'filled-rectangle (cdr (assq 'overlay-arrow fringe-indicator-alist)))
      (setq fringe-indicator-alist
            (cons '(overlay-arrow . filled-rectangle) fringe-indicator-alist)))))

(add-hook 'next-error-hook 'bar)

Atualização # 2:

Acabei de descobrir que, se você desligar a margem esquerda, verá o comportamento que descrevi no início: a janela é rolada para colocar o erro atual no topo. Então essa é outra possibilidade. (É o comportamento que vejo na minha configuração, pois não mostro margem.)

Há um erro neste comportamento, que acabei de relatar ( # 20829 ). O que conta (atualmente, até que o bug seja corrigido) é se a margem esquerda está aparecendo na janela selecionada quando você faz C-x `( next-error). (Atualmente) não é suficiente que a janela que mostra o buffer de compilação não mostre a margem esquerda.