enfatizzare l'errore corrente nella finestra * compilation *

Quando si esegue il comando di compilazione e si passa al "prossimo errore", emacs identifica la linea dell'errore corrente posizionando un piccolo triangolo nero, che punta a destra, nella parte sinistra del buffer * compilation * . Questo è carino, ma i miei vecchi occhi vorrebbero un indicatore più audace. L'obiettivo fondamentale qui è quello di essere in grado di identificare visivamente rapidamente quale linea emacs sta identificando come l'attuale errore del compilatore. Alcune soluzioni che mi vengono in mente:

1. una faccia diversa per l'errore corrente (ad esempio più grande).
2. un colore di sfondo diverso per l'errore corrente (qualcosa come hl-line-mode).
3. un triangolo più grande.

ma sono aperto anche ad altre idee.

Qualcuno mi può aiutare?

Volevo ottenere la stessa cosa, poiché spesso era doloroso trovare il messaggio di errore corrente nel buffer di compilazione. Questa soluzione si basa sul suggerimento di Drew di utilizzare a next-error-hookper evidenziare il messaggio di errore. Attualmente evidenzia solo la prima riga nel messaggio di errore, ma trovo che questo sia abbastanza buono.

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

Ecco un esempio di come modificare l'immagine bitmap che appare nella parte sinistra del *compilation*buffer (ad esempio, il *grep*buffer dei risultati):

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

Ecco un esempio di come impostare i colori delle bitmap frangia:

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

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

Ecco un esempio di come creare la propria bitmap marginale:

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

Non next-errorscorre il buffer degli errori di compilazione, in modo che l'errore corrente venga visualizzato come prima riga della finestra?

In caso contrario, non posiziona almeno il cursore sulla riga dell'errore corrente? In tal caso, e se il cursore non è abbastanza visibile per te, considera l'utilizzo hl-line-modedi evidenziare la linea corrente. Oppure considera l'utilizzo della libreria crosshairsper evidenziare la riga corrente e la colonna corrente.

Aggiorna dopo il tuo commento

Pensavo stessi invocando next-errornel buffer *compilation*. Se lo fai, la riga viene spostata verso l'alto, come ho descritto.

Ma se si sta invocando un next-errorbuffer esterno, *compilation*è necessario utilizzare next-error-hook, nel buffer*compilation* , per evidenziare la riga o il margine corrente o qualsiasi altra cosa, nel modo desiderato.

Ecco un esempio veloce e sporco:

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

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

(Naturalmente, è davvero solo bisogno di accendere hl-line-modeuna volta in quel buffer. Farlo come indicato sopra è eccessivo, ma non fa male. Si potrebbe pensare che si può solo aggiungere fooa grep-mode-hooko compilation-mode-hook. Ma quando quei ganci sono invocati non c'è no next-error-last-buffer.)

Nota:

1. Esistono due opzioni utente che controllano i modi per indicare l'hit nel buffer di origine (non nel buffer di compilazione): next-error-highlighte next-error-highlight-no-select. Offrono le stesse possibilità, ma sono utilizzate da comandi diversi. Le possibilità includono l'uso di una freccia a frangia o l'evidenziazione della partita per un certo tempo.

2. Ma non esiste tale opzione che controlli l'indicazione dell'hit corrente nel buffer *compilation*. Quindi Emacs offre due opzioni (dove probabilmente sarebbe sufficiente) per il buffer di origine ma nessuna opzione per il buffer di compilazione.

Si potrebbe prendere in considerazione la presentazione di una richiesta di miglioramento, per ottenere una soluzione simile per la compilazione (compresi grep) buffer: M-x report-emacs-bug. L'uso di un hook con la propria funzione per eseguire l'evidenziazione è OK, ma non dovrebbe essere necessario.

E se vuoi solo cambiare l'indicatore di frangia, puoi farlo (usa qualunque bitmap di frangia che desideri, invece di filled-rectangle- vedi (elisp) Bitmap di frangia per un elenco di quelli predefiniti):

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

Aggiornamento n. 2:

Ho appena scoperto che se si spegne mostrando la frangia a sinistra, si vedrà il comportamento che ho descritto all'inizio: la finestra viene fatta scorrere per mettere l'errore corrente in alto. Quindi questa è un'altra possibilità. (È il comportamento che vedo nella mia configurazione, dal momento che non mostro frangia.)

C'è un bug in questo comportamento, che ho appena segnalato ( # 20829 ). Ciò che conta (attualmente, fino a quando il bug non viene risolto) è se la frangia sinistra viene mostrata nella finestra selezionata quando lo fai C-x `( next-error). Non è (attualmente) sufficiente che la finestra che mostra il buffer di compilazione non mostri il margine sinistro.