Elrond

Questa estensione per Emacs dovrebbe fare quanto richiesto, ma non l’ho provata: http://www.dur.ac.uk/p.j.heslin/Software/Emacs/Download/ispell-multi.el (è un po’ vecchia, non so se funzioni con le ultime versioni di Emacs)

Provo a rispondere io: siunits non riceve modifiche dal 2007, invece siunitx è attivamente sviluppato (il manutentore dei due pacchetti è lo stesso) e può fare tutto quelli che si faceva con siunts, più tante altre cose.

Non so come funzioni su Windows (perché la gerarchi del file system è diversa rispetto a quella dei sistemi *nix, non c’è un’unica radice), però su GNU/Linux ci sono alcune comode scorciatoie. A parte `..’ per indicare la cartella superiore e `~/’ per la propria home, scrivendo come percorso del file da visitare
`~/Scrivania//etc/passwd`
il doppio slash ha il significato di “ignora tutto quello che c’è prima del secondo slash”, quindi il percorso realmente letto è il file `/etc/passwd’. È comodo quando bisogna visitare file in posizioni molto distanti da `default-directory’ (che nell’esempio di sopra potrebbe avere il valore `~/Scrivania’) e non si vuole perdere tempo a cancellare il percorso suggerito nel minibuffer (per esempio perché è un po’ troppo lungo e si è particolarmente pigri).

Per maggiori informazioni su queste scorciatoie puoi vedere il manuale: http://www.gnu.org/software/emacs/manual/html_node/emacs/Minibuffer-File.html#Minibuffer-File oppure in Emacs `C-h i d m Emacs RET m Minibuffer File’.

Il percorso predefinito è contenuto nella variabile `default-directory’, che equivale al percorso del file corrispondente al buffer aperto (vedi http://www.gnu.org/software/emacs/manual/html_node/emacs/File-Names.html#index-default_002ddirectory-808 oppure dentro Emacs: `C-h i d m Emacs RET m File Names’). Come spiegato nel manuale puoi cambiare percorso predefinito con il comando `cd’: `M-x cd RET C:/percorso/che/vuoi’. Quindi una possibilità sarebbe quella di mettere nel tuo file di inizializzazione
`(cd “C:/percorso/che/vuoi”)`
Un’altra possibilità è quella di impostare forzatamente `default-directory’. Puoi farlo con l’interfaccia di `customize-variable’ (`M-x customize-variable RET default-directory’) oppure aggiungendo al tuo file di inizializzazione (in alternativa all’istruzione di prima)
`(setq default-directory “C:/percorso/che/vuoi”)`

@samiam1000: se sei comunque interessato a leggere qualcosa sui Makefile puoi dare un’occhiata a http://elubuntu.altervista.org/LaTeX/Guide/make.pdf

[quote]Perché dico “tanto lavoro inutilmente”? Perché di far andare bibtex ogni volta non c’è alcun bisogno, tanto meno di compilare tre volte con LaTeX. Non c’è nemmeno bisogno di lanciare evince, perché dovrebbe essere capace di vedere la modifica del file pdf sul disco e aggiornare.

Ciao
Enrico

Non sono d’accordo che sia sempre tutto lavoro inutile. Intanto usando le variabili riesco sempre a riciclare i miei Makefile, cambio i valori di poche variabili e per il resto sono perfettamente riutizzabili, quindi il lavoro l’ho compiuto una volta e poi basta. Inoltre l’utilità dei Makefile entra in gioco soprattutto se non si vuole solo compilare il documento ma bisogna compiere delle altre operazioni precedentemente. Per esempio spesso ho bisogno di produrre dei grafici con gnuplot; in genere uso il terminale `epslatex’ quindi ottengo dei file EPS da convertire in PDF e anche questa operazione può essere automatizzata con il Makefile (anche se grazie a TeX Live 2010 mi risparmio questo passaggio). Inoltre ho delle regole per cancellare tutti i file temporanei prodotti nel caso in cui ciò sia necessario; ho una regola che mi crea un archivio compresso per distribuire tutta la cartella del codice sorgente del documento.

È vero che alcuni programmi permettono di compiere alcune di queste operazioni, ma i Makefile hanno il pregio di essere indipendenti dall’editor di testo usato e anche dal sistema operativo, GNU Make gira su tutti i sistemi Unix e anche Windows.

È anche vero che non è sempre necessario ricompilare tre volte un documento e la bibliografia ed è per questo che esiste texi2dvi (se solo funzionasse con il tuo pacchetto `frontespizio’ 👿 )

Scusa Elrond, ma avevi già evidenziato sul forum la tua guida su Make?
Sarebbe addirittura straordinario poter fare un articolo sui modi di compilazione nel mondo TeX.
Possiamo prendercela abbastanza comoda, e scrivere, a contributo aperto, un articolo per ArS.
L’unione fa la forza!!
R.[/quote]
Sì: http://www.guit.sssup.it/phpbb/viewtopic.php?t=6690

Ho trovato questa minor mode per evidenziare le parentesi corrispondenti: http://centaur.maths.qmw.ac.uk/emacs/files/latex-paren.el

Emacs è normalmente in grado di far corrispondere le parentesi chiuse a quelle aperte, ma con questa modalità ci sarà corrispondenza anche fra [tt]\[ [/tt] e [tt]\][/tt], [tt]\([/tt] e [tt]\)[/tt], [tt]\{[/tt] e [tt]\}[/tt] che altrimenti verrebbero riconosciute.

Riporto qui il file latex-paren.el perché su internet l’ho trovato solo sul sito sopra linkato e non vorrei che un giorno sparisca 😆
`;;; latex-paren.el — highlight matching LaTeX parens.

;; F.J.Wright@Maths.QMW.ac.uk, 26 September 1998

;; For GNU Emacs 20 only

;; Based closely on paren.el by RMS

;; latex-paren.el is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; It is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.

;;; Commentary:

;; Load this and it will improve show-paren-mode highlighting on
;; whatever paren matches the one before or after point in LaTeX mode.
;; It attempts to handle \(, \[, \{ and $ as well as (, [ and {.

;; I suggest that you put this library somewhere in your `load-path'
;; and hang it on `latex-mode-hook' by putting this in `.emacs', so
;; that it is loaded only if necessary:

;; (add-hook 'latex-mode-hook
;; (function (lambda () (require 'latex-paren))))

;;; Code:

;; General code to handle overloading of the standard show-paren-mode
;; to allow buffer-local handling of paren highlighting. (Done this
;; way to avoid modifying, and remain compatible with, paren.el.
;; Cannot just use a local hook, because it may be necessary to
;; REPLACE the standard function, which would be on the global hook,
;; and a local hook can only add to the global hook value.)

(require 'paren)

(defvar show-paren-functions 'std-show-paren-function
“Function (or list of functions) to highlight matching parentheses etc.
The function(s) will be run automatically by a timer.
Give this variable buffer-local values to run custom functions.
Not to be changed by the casual user, hence not customizable!”)

(fset 'std-show-paren-function (symbol-function 'show-paren-function))
(defun show-paren-function () (run-hooks 'show-paren-functions))

;; Specific code for LaTeX mode.

(let ((fn (function (lambda ()
(set (make-local-variable 'show-paren-functions)
'latex-show-paren-function)
))))
(add-hook 'latex-mode-hook fn)
(apply fn nil))

(defun latex-show-paren-function ()
;; Do nothing if no window system to display results with.
;; Do nothing if executing keyboard macro.
;; Do nothing if input is pending.
(when window-system
(let (pos dir mismatch face (oldpos (point)) charquote)
(cond ((eq (char-syntax (preceding-char)) ?\))
(setq dir -1)
(setq charquote (uncharquote (char-after (- (point) 2)))))
((eq (char-syntax (following-char)) ?\()
(setq dir 1)
(setq charquote (uncharquote (preceding-char))))
((and (eq (char-syntax (preceding-char)) ?\$)
(not (eq (char-syntax (char-after (- (point) 2))) ?/)))
(setq dir -1))
((and (eq (char-syntax (following-char)) ?\$)
(not (eq (char-syntax (preceding-char)) ?/)))
(setq dir 1)))
;;
;; Find the other end of the sexp.
(when dir
(save-excursion
(save-restriction
;; Determine the range within which to look for a match.
(when blink-matching-paren-distance
(narrow-to-region
(max (point-min) (- (point) blink-matching-paren-distance))
(min (point-max) (+ (point) blink-matching-paren-distance))))
;; Scan across one sexp within that range.
;; Errors or nil mean there is a mismatch.
(condition-case ()
(setq pos (scan-sexps (point) dir))
(error (setq pos t mismatch t)))
;; If found a “matching” paren, see if it is the right
;; kind of paren to match the one we started at.
(when (integerp pos)
(let* ((beg (min pos oldpos)) (end (max pos oldpos))
(begchar (char-after beg)))
(setq mismatch
(not (eq (char-before end)
(if (eq (char-syntax begchar) ?\$) begchar
;; This can give nil.
(matching-paren begchar))))))))))
(if charquote (recharquote charquote))
;;
;; Highlight the other end of the sexp, or unhighlight if none.
(if (not pos)
(progn
;; If not at a paren that has a match,
;; turn off any previous paren highlighting.
(and show-paren-overlay (overlay-buffer show-paren-overlay)
(delete-overlay show-paren-overlay))
(and show-paren-overlay-1 (overlay-buffer show-paren-overlay-1)
(delete-overlay show-paren-overlay-1)))
;;
;; Use the correct face.
(if mismatch
(progn
(if show-paren-ring-bell-on-mismatch
(beep))
(setq face 'show-paren-mismatch-face))
(setq face 'show-paren-match-face))
;;
;; If matching backwards, highlight the closeparen
;; before point as well as its matching open.
;; If matching forward, and the openparen is unbalanced,
;; highlight the paren at point to indicate misbalance.
;; Otherwise, turn off any such highlighting.
(if (and (= dir 1) (integerp pos))
(when (and show-paren-overlay-1
(overlay-buffer show-paren-overlay-1))
(delete-overlay show-paren-overlay-1))
(let ((from (if (= dir 1)
(point)
(forward-point -1)))
(to (if (= dir 1)
(forward-point 1)
(point))))
(if show-paren-overlay-1
(move-overlay show-paren-overlay-1 from to (current-buffer))
(setq show-paren-overlay-1 (make-overlay from to)))
;; Always set the overlay face, since it varies.
(overlay-put show-paren-overlay-1 'face face)))
;;
;; Turn on highlighting for the matching paren, if found.
;; If it's an unmatched paren, turn off any such highlighting.
(unless (integerp pos)
(delete-overlay show-paren-overlay))
(let ((to (if (or (eq show-paren-style 'expression)
(and (eq show-paren-style 'mixed)
(not (pos-visible-in-window-p pos))))
(point)
pos))
(from (if (or (eq show-paren-style 'expression)
(and (eq show-paren-style 'mixed)
(not (pos-visible-in-window-p pos))))
pos
(save-excursion
(goto-char pos)
(forward-point (- dir))))))
(if show-paren-overlay
(move-overlay show-paren-overlay from to (current-buffer))
(setq show-paren-overlay (make-overlay from to))))
;;
;; Always set the overlay face, since it varies.
(overlay-put show-paren-overlay 'face face)))))

(defun uncharquote (c)
(cond ((eq (char-syntax c) ?/)
(modify-syntax-entry c “.”) c)))

(defun recharquote (c) (modify-syntax-entry c “/”))

(provide 'latex-paren)

;;; latex-paren.el ends here`

Come scritto nei commenti, per utilizzare questa modalità basta mettere il file in una cartella del load-path e aggiungere al file di inizializzazione
`(add-hook 'latex-mode-hook
(function (lambda () (require 'latex-paren))))`

C’è scritto che funziona solo su Emacs 20 ma io ce l’ho su Emacs 23.2

EDIT. Mi devo correggere: forse se è attivo AUCTeX non funziona 🙁