Go to the first, previous, next, last section, table of contents.


Divers

Ceci est la cinquième partie de la Foire Aux Questions sur XEmacs. Cette section est consacrée à tout ce qui n'avait pas sa place dans les sections précédentes.

Comment mettre du code source en évidence avec font-lock ?

Pour la plupart des modes, font-lock est déjà configuré et a juste besoin d'être activé. Ceci peut être fait par M-x font-lock-mode, ou en faisant en sorte que XEmacs le lance automatiquement en ajoutant des lignes comme :

(add-hook 'emacs-lisp-mode-hook	'turn-on-font-lock)
(add-hook 'dired-mode-hook	'turn-on-font-lock)

à votre `.emacs'. Voir le fichier `etc/sample.emacs' pour des détails supplémentaires.

Voir aussi Syntax Highlighting dans le menu Options. N'oubliez pas de sauver les options.

Je n'aime pas le mode cc. Comment utiliser l'ancien mode c ?

Bien, d'abord, assurez-vous d'être sûr de vouloir le faire. Le mode cc est bien plus puissant que l'ancien mode c. Si vous avez des problèmes pour faire fonctionner vos anciens offsets, essayez plutôt d'utiliser c-set-offset. Vous pouvez aussi utiliser le paquetage cc-compat.

Mais, si vous insistez, ajoutez les lignes suivantes à votre `.emacs' :

(fmakunbound 'c-mode)
(makunbound 'c-mode-map)
(fmakunbound 'c++-mode)
(makunbound 'c++-mode-map)
(makunbound 'c-style-alist)
(load-library "old-c-mode")
(load-library "old-c++-mode")	

Ceci doit être fait avant tout autre référence à c-mode ou c++-mode.

Comment, par défaut, avoir `plus' de mise en valeur de la syntaxe ?

Utilisez le code suivant dans votre `.emacs' :

(setq-default font-lock-maximum-decoration t)

Dans les versions de XEmacs antérieures à 19.14, vous deviez utiliser une solution tarabiscotée comme celle-ci :

(setq c-font-lock-keywords c-font-lock-keywords-2
      c++-font-lock-keywords c++-font-lock-keywords-2
      lisp-font-lock-keywords lisp-font-lock-keywords-2)

Cela fonctionnera avec C, C++ et Lisp.

Voir aussi Syntax Highlighting dans le menu Options. N'oubliez pas de sauver les options.

Comment activer l'indentation automatique ?

Placez la ligne suivante dans votre `.emacs' :

(setq indent-line-function 'indent-relative-maybe)

Si vous voulez un peu de fantaisie, essayez le paquetage filladapt, disponible en standard avec XEmacs. Placez ceci dans votre `.emacs' :

(require 'filladapt)
(add-hook 'text-mode-hook    'turn-on-filladapt-mode)
;;; et autres ...

Vous pouvez personnaliser le remplissage et le remplissage adaptatif avec Customize. Choisissez Customize->Emacs->->Editing->Fill->Fill... à partir du menu Options, ou tapez M-x customize RET fill RET.

Notez que les modes textes qui se comportent bien lanceront text-mode-hook par défaut (c'est ce que fait Message, par exemple). Pour les mauvais, vous devez utiliser add-hooks.

Remarquez que le paquetage fa-extras n'est plus utile.

Comment faire pour que XEmacs soit en mode text/auto-fill par défaut ?

Essayez le lisp suivant dans votre `.emacs' :

(setq default-major-mode 'text-mode)
(setq text-mode-hook 'turn-on-auto-fill)

ATTENTION : La modification de la valeur de default-major-mode du fundamental-mode menace la bonne marche de beaucoup de code intégré qui attend que les tampons nouvellement créés soient en fundamental-mode (passer de fundamental-mode à text-mode ne devrait pas faire trop de ravages, mais modifier quelque chose de plus exotique comme un mode lisp briserait de nombreux paquetages Emacs).

Notez que, par défaut, Emacs démarre dans un tampon *scratch* en initial-major-mode, qui est par défaut lisp-interaction-mode. Donc, ajouter la forme suivante à votre fichier d'initialisation Emacs fera que le tampon *scratch* initial sera dans un text-mode avec remplissage automatique :

(setq initial-major-mode
      (lambda ()
        (text-mode)
        (turn-on-auto-fill)))

Notez qu'après que le chargement de votre fichier d'initialisation, si inhibit-startup-message est nil (la valeur par défaut) et que le tampon de démarrage est *scratch*, alors le message de démarrage sera inséré dans *scratch* ; il sera supprimé après un certain délai en effaçant le tampon *scratch* complet. Gardez à l'esprit cette utilisation par défaut de *scratch* si vous désirez faire une manipulation initiale quelconque de *scratch* à partir de votre fichier d'initialisation d'Emacs. En particulier, tout ce que vous insérez dans *scratch* à partir de votre fichier d'initialisation sera détruit plus tard. De plus, si vous changez le mode du tampon *scratch*, assurez-vous que cela n'interfèrera pas avec une possible insertion ultérieure du message de démarrage (par exemple, si vous mettez *scratch* dans un mode non standard qui a des règles automatiques de verrouillage des fontes, alors le message de démarrage peut être fontifié d'une drôle de façon, par exemple comme du code d'un langage de programmation quelconque).

Comment lancer un deuxième tampon shell ?

Dans le tampon *shell* :

M-x rename-buffer RET *shell-1* RET
M-x shell RET

Ceci lancera un second shell. Le point clé est qu'aucun tampon nommé `*shell*' ne peut exister. Il peut être préférable d'utiliser M-x rename-uniquely pour renommer le tampon *shell* au lieu de M-x rename-buffer.

un telnet dans un shell filtre trop

J'utilise la fonction Emacs M-x shell, et je voudrais invoquer et utiliser une session telnet à l'intérieur. Tout fonctionne correctement sauf que, maintenant, tous les `^M' sont filtrés par Emacs. Des solutions ?

Utilisez M-x rsh ou M-x telnet pour ouvrir des sessions distantes plutôt que de faire un rsh ou un telnet dans le tampon shell local.

Pourquoi l'émulation edt ne fonctionne pas ?

Nous ne le savons pas, mais vous pouvez utiliser l'émulation tpu-edt à la place. Elle fonctionne bien et est un peu plus agréable que l'émulation edt standard. Pour ce faire, ajoutez la ligne suivante à votre `.emacs' :

(tpu-edt)

Si vous ne voulez pas remplacer C-h avec un menu d'aide de style edt, ajoutez aussi ceci :

(global-set-key [(control h)] 'help-for-help)

Comment émuler VI et l'utiliser comme mode par défaut ?

Nous recommandons viper comme émulateur VI. Pour le mettre par défaut, ajoutez ceci à votre `.emacs' :

(viper-mode)

Michael Kifer <kifer@CS.SunySB.EDU> écrit :

Ceci doit être ajouté le plus près possible du début de votre `.emacs', sinon certains modes mineurs risque de ne pas être viperisés.

[Cette question est intentionnellement vide]

Question obsolète, laissée vide pour éviter la renumérotation.

Filladapt ne fonctionne pas en 19.15.

Filladapt 2.x est inclus avec la version 19.15. Avec elle, filladapt est maintenant un mode mineur et les modes mineurs sont traditionnellement désactivés par défaut. En mettant ce qui suit dans votre `.emacs', cela l'activera pour tous les tampons :

(setq-default filladapt-mode t)

Utilisez turn-on-filladapt-mode pour activer Filladapt sur des modes majeurs précis, comme ceci :

(add-hook 'text-mode-hook 'turn-on-filladapt-mode) 

Comment empêcher gnuserv d'ouvrir un nouveau cadre ?

Si vous configurez la variable gnuserv-frame avec le cadre qui devrait être utilisé pour afficher les tampons qui sont remontés, il n'y aura pas de nouveau cadre créé. Par exemple, vous pouvez mettre

(setq gnuserv-frame (selected-frame))

au début de votre `.emacs', pour être sûr que le premier cadre créé sera celui utilisé pour vos tampons gnuserv.

À partir de la version 19.15, il existe une option pour configurer la cible gnuserv avec le cadre courant. Voir Options->"Other Window" Location->Make current frame gnuserv target

À partir de XEmacs-20.3, vous pouvez aussi changer cela avec Customize. Choisissez Customize->Emacs->Environment->Gnuserv->Gnuserv Frame... à partir du menu Options, ou tapez M-x customize RET gnuserv RET.

Comment démarrer gnuserv pour que chaque XEmacs suivant soit un client ?

Mettez ce qui suit dans votre fichier `.emacs' pour lancer le serveur :

(gnuserv-start)

Lancez votre XEmacs comme d'habitude. Puis, vous pouvez faire :

gnuclient randomfilename

à partir de la ligne de commande pour que votre processus XEmacs ouvre un nouveau cadre et charge randomfilename dans cette fenêtre. Lorsque vous aurez fini d'éditer randomfilename, tapez C-x # pour détruire le tampon et vous débarrasser du cadre.

Voir aussi la page man de gnuclient.

De drôles de choses se passent en mode shell.

Quelquefois (i.e. cela ne se répète pas et je ne sais pas pourquoi cela arrive), lorsque je tape en mode shell, je tape Entrée et seule une partie de la commande est passée au shell et un prompt vide est renvoyé. Si je retape Entrée, le reste de la commande précédente est passée au shell.

Martin Buchholz <Martin.Buchholz@sun.com> écrit :

Il y a un problème connu avec l'interaction entre csh et l'option filec et XEmacs. Ajoutez ce qui suit à votre `.cshrc':

if ( "$TERM" == emacs || "$TERM" == unknown ) unset filec

Où obtenir le dernier mode cc ?

Barry A. Warsaw <bwarsaw@cnri.reston.va.us> écrit :

Il peut être obtenu à partir de <URL:http://www.python.org/ftp/emacs/>.

Je trouve le mode auto-show déconcertant. Comment le désactiver ?

auto-show-mode contrôle si une barre de défilement horizontale apparaît magiquement ou non lorsqu'une ligne est trop longue pour être affichée. Ceci est activé par défaut. Pour le désactiver, placez ce qui suit dans votre `.emacs' :

(setq auto-show-mode nil)
(setq-default auto-show-mode nil)

Comment avoir deux instances d'info ?

C'est impossible car le paquetage info n'offre pas de tampons info multiples.

Je suis passé à XEmacs 19.14 et gnuserv ne fonctionne plus

Mark Daku <daku@nortel.ca> écrit :

Il se trouve que j'utilise une version plus ancienne de gnuserv. L'installation ne place pas le binaire dans le répertoire public bin. Elle le place dans `lib/xemacs-19.14/hppa1.1-hp-hpux9.05/gnuserv'. Aurait-il dû être placé dans `bin/hppa1.1-hp-hpux9.0' ?

Y a t'il mieux que le mode LaTeX ?

David Kastrup <dak@fsnif.neuroinformatik.ruhr-uni-bochum.de> écrit :

Les modes TeX standards laissent beaucoup à désirer, et sont maintenus avec indulgence. Les utilisateurs sérieux de TeX utilisent AUC TeX (voir See section Qu'est-ce qu'AUC TeX ? Où l'obtenir ?).

Y a t'il moyen de lancer un nouvel XEmacs s'il n'y a pas de gnuserv qui tourne, et sinon utiliser gnuclient ?

Jan Vroonhof <vroonhof@math.ethz.ch> écrit :

Voici une des solutions, nous l'avons dans un script appelé etc/editclient.sh.

#!/bin/sh
if gnuclient -batch -eval t >/dev/null 2>&1
then
  exec gnuclient ${1+"$@"}
else
  xemacs -unmapped -f gnuserv-start &
  until gnuclient -batch -eval t >/dev/null 2>&1
  do
    sleep 1
  done
  exec gnuclient ${1+"$@"}
fi

Notez qu'il y a un problème connu lorsqu'on lance XEmacs et gnuclient -nw sur le même terminal.

Différence dans les séquences de touches entre XEmacs et GNU Emacs.

Erik Naggum <erik@naggum.no> écrit :

Emacs a un héritage de claviers qui produisent des caractères avec des bits modicateurs et fait donc correspondre une grande variété de systèmes d'entrée avec ce schéma, même aujourd'hui. À la place, XEmacs est optimisé pour les événements X. Ceci est la cause d'incompatibilités dans la façon dont les séquences de touches sont précisées, mais Emacs et XEmacs recevront tous les deux une séquence de touche sous la forme d'un vecteur de listes de modificateurs qui se terminent par une touche, par exemple, pour lier M-C-a, vous direz [(meta control a)] dans les deux cas. XEmacs dispose d'une forme abrégée pour une touche simple, simplement (meta control a). Emacs possède une forme abrégée en string-characters (caractères ASCII) pour les modificateurs Control et Meta, comme dans `\M-\C-a'. Les utilisateurs de XEmacs doivent retenir que la forme abrégée ne fonctionne que pour les séquences de touches à un seul caractère, alors que les utilisateurs d'Emacs doivent tenir compte du fait qu'un string-character est plutôt limité. Précisément, un string-character ne peut prendre que 256 valeurs différentes, dont 128 ont le modificateur Meta, et 128 ne l'ont pas. Dans chacune de ces parties, seuls 32 caractères ont le modificateur Control. [(meta control A)] diffère de [(meta control a)] car la casse diffère, alors que `\M-\C-a' et `\M-\C-A' désignent la même chose. Il est conseillé aux programmeurs d'utiliser la forme la plus commune car elle est plus lisible et moins sujette aux erreurs et parce qu'elle est reconnue par les deux Emacs.

Une autre méthode (préférable) d'être sûr des séquences de touches est d'utiliser la fonction read-kbd-macro qui prend une chaîne comme `C-c <up>', et la convertit en sa représentation interne de l'Emacs que vous utilisez. Cette fonction est disponible en XEmacs comme en GNU Emacs.

Puis-je générer des événements clavier bidon ?

Je me demande s'il y a une fonction intéractive qui pourrait produire des événements clavier bidon. Je pourrais ainsi les mapper simplement dans XEmacs.

Ceci semble fonctionner :

(defun cg--generate-char-event (ch)
  "Produit un evenement, comme si ch avait ete tape"
  (dispatch-event (character-to-event ch)))

;;  Backspace et Delete
(global-set-key [backspace]
                (lambda () (interactive) (cg--generate-char-event 127)))
(global-set-key [unknown_keysym_0x4]
                (lambda () (interactive) (cg--generate-char-event 4)))

Pouvez-vous expliquer read-kbd-macro plus précisément ?

La fonction read-kbd-macro renvoie la représentation interne à Emacs d'une chaîne lisible (qui lui est passée en paramètre). Ainsi :

(read-kbd-macro "C-c C-a")
     => [(control ?c) (control ?a)]

(read-kbd-macro "C-c C-. <up>")
     => [(control ?c) (control ?.) up]

En GNU Emacs, les mêmes formes seront évaluées en ce que comprend GNU Emacs en interne -- les séquences "\C-x\C-c" et [3 67108910 up], respectivement.

La syntaxe lisible exacte est définie dans la chaîne de documentation de edmacro-mode. Je la répète ici pour être complet.

Format des macros claviers pendant l'édition :

Un texte est divisé en mots séparés par des espaces. À part les mots décrits ci-dessous, les caractères de chaque mot passent directement comme caractères à la macro. L'espace qui sépare les mots est ignorée. L'espace dans la macro doit être explicitement écrite, comme dans foo SPC bar RET.

Tout mot peut être préfixé par un multiplicateur, formé à l'aide d'un nombre décimal et de * : 3*<right> == <right> <right> <right> et 10*foo == foofoofoofoofoofoofoofoofoofoo.

Plusieurs touches de texte peuvent être liées entre elles pour former un mot, mais vous devez ajouter une espace si le mot ressemble à l'une des notations suivantes : ; ; ; est une macro clavier avec trois points-virgules, alors que ;;; est un commentaire. De même, \ 1 2 3 représente trois touches, mais \123 est une seule touche écrite en octal et < right > représente sept touches mais <right> est une seule touche de fonction. En cas de doute, utilisez des espaces.

Quel est l' impact sur la performance de l'utilisation de let ?

Dans la plupart des cas, cela n'est pas notable. De plus, on ne peut éviter let -- après tout, il faut bien lier ses variables locales. Certains posent des questions pour savoir s'il faut imbriquer les let ou n'utiliser qu'un let par fonction. Je pense que, pour des raisons de clarté et de maintenance (et d'une possible implantation future), les let doivent être utilisés imbriqués de façon à produire un code clair.

Quelle est l'utilisation recommandée de setq ?

Quelle est la mauvaise utilisation classique de setq ?

Une mauvaise utilisation typique est probablement de faire un setq sur une variable qui devait être locale. Un telle variable restera liée pour toujours et jamais libérée par le garbage collector. Par exemple, le code faisant :

(defun my-function (whatever)
  (setq a nil)
  ... contruire une grande liste a ...
  ... et sortir ...)

est mauvais, car a continuera de consommer de la mémoire et ne sera jamais libérée. La façon correcte de faire cela est :

(defun my-function (whatever)
  (let (a)             ; initialisation par defaut a nil
    ... contruire une grande liste a ...
    ... et sortir, en libérant 'a'  ...)

C'est non seulement plus propre syntaxiquement parlant, mais cela permet à Emacs de libérer les objets que a référençait.

Remarquez que même les variables globales ne devraient pas être initialisées avec setq sans les avoir d'abord définies avec defvar, à cause des avertissements produits par le byte-compilateur. La raison des ces avertissements est la suivante :

(defvar flurgoze  nil)    ; ok, variable globale interne
...

(setq   flurghoze t)      ; oops !  une erreur de typo, mais correct
                          ; semantiquement, cependant le compilateur
                          ; previendra.

While compiling toplevel forms:
  ** assignment to free variable flurghoze

J'aime la forme do de cl, est-ce qu'elle ralentit les choses ?

Elle ne devrait pas. Voici ce que Dave Gillespie a dit sur les performances de cl.el :

De nombreuses caractéristiques avancées de ce paquetage, comme defun*, loop et setf sont implantées comme des macros Lisp. En code compilé, ces notations complexes seront traduites en leur code Lisp équivalent qui est simple et efficace. Par exemple, les formes :

(incf i n)
(push x (car p))

sont traduites, au moment de la compilation, par les formes :

(setq i (+ i n))
(setcar p (cons x (car p)))

qui sont les moyens les plus efficaces pour faire ces opérations en Lisp. Ainsi, il n'y a aucun perte de performance à utiliser les formes plus lisibles incf et push dans votre code compilé.

Le code interprété, par contre, doit traduire ces macros à chaque fois qu'elles sont exécutées. Pour cette raison, il est fortement recommandé que le code qui utilise intensivement les macros soit compilé (les caractéristiques nommées Forme Spéciale au lieu de Fonction dans ce manuel sont des macros). Une boucle utilisant incf une centaine de fois s'exécutera considérablement plus vite si elle est compilée et nécessitera moins de garbage collect car l'expansion de macro n'aura pas à être produite, utilisée et nettoyée une centaine de fois.

Vous pouvez comprendre quelle est l'expansion d'une macro en utilisant la fonction cl-prettyexpand.

J'aime la récursion, est-ce que cela ralentit ?

Oui. Le byte compilateur Emacs ne peut pas faire grand chose pour optimiser la récursion. Mais est-ce que cela concerne réellement Emacs ? Sa lenteur est surtout attribuable à certains mécanismes internes comme le réaffichage, ou du fait que c'est un interpréteur.

N'essayez pas de rendre votre code plus affreux sous prétexte de gagner très peu de rapidité. Ça n'en vaut généralement pas la peine.

Comment mettre un glyph comme annotation dans un tampon ?

Voici une solution pour insérer une annotation glyph au début du tampon :

(make-annotation (make-glyph '([FORMAT :file FILE]
                               [string :data "fallback-text"]))
                 (point-min)
                 'text
                 (current-buffer))

Remplacez `FORMAT' par un symbole non quoté représentant le format de l'image (par exemple, xpm, xbm, gif, jpeg, etc.).

À la place de `FILE', mettez le nom du fichier image (par exemple, `/usr/local/lib/xemacs-20.2/etc/recycle.xpm').

Vous pouvez transformer cela en fonction (vous demandant éventuellement un nom de fichier), et insérer le glyph à (point) au lieu de (point-min).

`map-extents' ne parcourt pas toute la superficie !

J'ai essayé d'utiliser map-extents pour réaliser une opération sur toute la superficie d'une région. Cependant, cela semble s'arrêter après avoir traité une partie aléatoire de la superficie. Est-ce buggé ?

Non. La documentation de map-extents indique qu'il itérera sur la superficie tant que FONCTION renvoie nil. Les programmeurs inexpérimentés oublient souvent de renvoyer explicitement nil, ce qui donne du code buggé. Par exemple, le code suivant est sensé détruire toute les étendues d'un tampon, et produire autant de messages coucou !.

(map-extents (lambda (ext ignore)
                     (delete-extent ext)
                     (message "coucou !")))

Au lieu de cela, elle ne détruira que la première et s'arrêtera car message renverra une valeur non nil. Le code correct est :

(map-extents (lambda (ext ignore)
                     (delete-extent ext)
                     (message "coucou !")
                      nil))

Comment désactiver le son ?

Ajoutez la ligne suivante à votre `.emacs' :

(setq bell-volume 0)
(setq sound-alist nil)

Cela rendra votre XEmacs totalement silencieux, même le bip par défaut (celui du terminal) sera désactivé.

À partir de XEmacs-20.2 vous pouvez aussi utiliser Customize. Choisir Customize->Emacs->Environment->Sound->Sound... à partir du menu Options, ou tapez M-x customize RET sound RET.

Comment avoir des sons sympas au lieu d'un bip ennuyeux ?

Assurez-vous que XEmacs a été compilé avec la gestion du son, et ajoutez ça dans votre `.emacs' :

(load-default-sounds)

La gestion du son avec XEmacs 19.14 a été beaucoup améliorée par rapport aux versions précédentes.

Qu'est-ce que NAS, comment l'obtenir ?

Voir See section Compiler XEmacs avec Netaudio. pour une explication du Network Audio System.

Les sons de Sunsite ne marchent pas

J'ai quelques problèmes avec les sons que j'ai téléchargé depuis Sunsite. Ils marchent lorsque je les lance avec showaudio ou que je fais un cat directement sur `/dev/audio', mais XEmacs refuse de les jouer.

Markus Gutschke <gutschk@uni-muenster.de> écrit :

[La plupart de] Ces fichiers ont un en-tête (erroné) de 24 octets qui renseigne sur le format dans lequel ils ont été enregistrés. Si vous en faites un cat sur `/dev/audio', l'en-tête sera ignoré et le comportement par défaut de `/dev/audio' sera utilisé (uLaw 8 kHz). Il est sûrement possible de corriger l'en-tête en le passant par sox et en donnant des paramètres explicites pour préciser le format d'échantillonnage ; vous devez alors faire une conversion nulle de SunAudio vers SunAudio.

Comment indenter correctement les clauses if avec XEmacs ?

Je voudrais que XEmacs indente toutes les clauses if de Common Lisp avec la même nombre d'espace plutôt que d'indenter la troisième clause différement des deux premières.

Une façon de faire est d'ajouter à `.emacs' :

(put 'if 'lisp-indent-function nil)

Cependant, le paquetage `cl-indent.el' venant avec XEmacs configure ce genre d'indentation par défaut. cl-indent connaît aussi beaucoup d'autres formes spécifiques à Common Lisp. Pour utiliser cl-indent, on peut faire comme ceci :

(load "cl-indent")
(setq lisp-indent-function (function common-lisp-indent-function))

On peut aussi personnaliser `cl-indent.el' pour qu'il imite par défaut l'indentation if avec then indenté plus que else. Voici comment :

(put 'if 'common-lisp-indent-function '(nil nil &body))

De plus, une nouvelle version (1.2) de `cl-indent.el' a été postée dans comp.emacs.XEmacs le 12/9/94. Cette version contient plus de documentation que les versions précédentes. Ceci peut s'avérer utile si vous voulez personnaliser toutes les fonctions d'indentation.

La fontification se fige lors de l'édition d'un fichier Postscript

Lorsque j'essaie d'éditer un fichier Postscript, cela se bloque en disant : `fontifying 'filename' (regexps....)'. Si je presse C-c dans la fenêtre où XEmacs a été lancé, il revient soudainement à la vie.

Cela était causé par un bug des expressions rationnelles utilisée lors de la colorisation (font-lock) du Postscript, corrigé depuis la version 19.13. Pour les versions antérieures XEmacs, examinez votre fichier `.emacs'. Vous devriez avoir une ligne comme :

(add-hook 'postscript-mode-hook	'turn-on-font-lock)

Ôtez-la, redémarrez XEmacs, et n'essayez plus de fontifier vos fichiers Postscript.

Comment imprimer un tampon font-locké en WYSIWYG ?

font-lock a bel aspect. Comment puis-je imprimer (WYSIWYG) le document mis en évidence ?

Le paquetage `ps-print.el', qui est maintenant inclus avec XEmacs offre la possibilité de le faire. Le code source contient les instructions complètes pour son utilisation dans `<racine_sources_xemacs>/lisp/packages/ps-print.el'.

Faire fonctionner M-x lpr avec une imprimante Postscript

Mon imprimante est une imprimante Postscript et lpr ne fonctionne que pour les fichiers Postscript, comment faire marcher M-x lpr-region et M-x lpr-buffer ?

Mettez quelque chose comme ça dans votre `.emacs' :

(setq lpr-command "a2ps")
(setq lpr-switches '("-p" "-1"))

Si vous n'utilisez pas a2ps pour convertir l'ASCII en Postscript (et pourquoi ? il est libre !), remplacez son appel par la commande que vous utilisez. Notez aussi que certaines version d'a2ps nécessitent un `-Pprinter' pour assurer le spooling.

Comment préciser les chemins que XEmacs utilise pour trouver les fichiers ?

Vous pouvez préciser les chemins à utiliser à l'aide d'un certain nombre d'options lorsque vous lancez configure. Voir la section MAKE VARIABLES dans le fichier INSTALL du niveau le plus haut de la distribution XEmacs pour une liste de ces options.

La plupart du temps, la solution la plus simple est de ne pas préciser les chemins comme avec GNU Emacs. XEmacs peut généralement déterminer dynamiquement les chemins nécessaires au moment de l'exécution. Le seul chemin qui doit être précisé est le répertoire racine de l'installation. Ceci peut se faire en passant l'option --prefix à configure. Pour une description de l'arborescence d'installation de XEmacs, consultez le fichier `NEWS'.

[Cette question est intentionellement vide]

Question obsolète, laissez vide pour éviter la renumérotation.

Puis-je avoir la fin du tampon marquée par un moyen quelconque ?

Par exemple, avec `[END]' ?

Essayez ceci :

(let ((ext (make-extent (point-min) (point-max))))
  (set-extent-property ext 'start-closed t)
  (set-extent-property ext 'end-closed t)
  (set-extent-property ext 'detachable nil)  
  (set-extent-end-glyph ext (make-glyph [string :data "[END]"])))

Comme il s'agit de XEmacs, vous pouvez préciser un icône à afficher sur les périphériques du système de fenêtrage. Pour ce faire, modifiez l'appel make-glyph pour faire quelque chose comme :

(make-glyph '([xpm :file "~/something.xpm"]
              [string :data "[END]"]))

Vous pouvez mettre vous même en ligne la définition XPM en précisant :data au lieu de :file. Voici une version complète fonctionnant à la fois sur des terminaux X et texte :

(let ((ext (make-extent (point-min) (point-max))))
  (set-extent-property ext 'start-closed t)
  (set-extent-property ext 'end-closed t)
  (set-extent-property ext 'detachable nil)  
  (set-extent-end-glyph ext (make-glyph '([xpm :data "\
/* XPM */
static char* eye = {
\"20 11 7 2\",
\"__ c None\"
\"_` c #7f7f7f\",
\"_a c #fefefe\",
\"_b c #7f0000\",
\"_c c #fefe00\",
\"_d c #fe0000\",
\"_e c #bfbfbf\",
\"___________`_`_`___b_b_b_b_________`____\", 
\"_________`_`_`___b_c_c_c_b_b____________\", 
\"_____`_`_`_e___b_b_c_c_c___b___b_______`\", 
\"___`_`_e_a___b_b_d___b___b___b___b______\", 
\"_`_`_e_a_e___b_b_d_b___b___b___b___b____\", 
\"_`_`_a_e_a___b_b_d___b___b___b___b___b__\", 
\"_`_`_e_a_e___b_b_d_b___b___b___b___b_b__\", 
\"___`_`_e_a___b_b_b_d_c___b___b___d_b____\", 
\"_____`_`_e_e___b_b_b_d_c___b_b_d_b______\", 
\"_`_____`_`_`_`___b_b_b_d_d_d_d_b________\", 
\"___`_____`_`_`_`___b_b_b_b_b_b__________\", 
} ;"]
                                          [string :data "[END]"]))))

Notez que vous pouvez en faire une fonction et la placer dans un hook. Nous laissons ceci comme exercice pour le lecteur.

Comment insérer la date du jour dans un tampon ?

Comme ceci :

(insert (current-time-string))

Est-ce que seules certaines classes de caractères sont disponibles pour les abréviations ?

Markus Gutschke <gutschk@uni-muenster.de> écrit :

Oui, les abréviations ne fonctionnent qu'avec des chaînes de mots. Bien que XEmacs ne vous empêche pas de définir (par exemple, avec C-x a g ou C-x a l) des abbréviations qui contienne des caractères spéciaux, il refusera de les étendre. Vous devez donc vous assurer que l'abréviation ne contienne que des lettres et des chiffres. Ceci signifie que `xd', `d5' et `5d' sont des abréviations correctes, mais que `&d' et `x d' ne le sont pas.

Si cela vous semble confus, (re)lisez la documentation en ligne sur les abréviations (C-h i m XEmacs RET m Abbrevs RET) et revenez lire cette question/réponse.

Cette limitation a été levée depuis XEmacs 20.3.

Comment obtenir ces si belles lignes X-Face ?

D'abord, il y a un site FTP qui décrit les X-Faces et a les outils mentionnés ci-dessous : <URL:ftp://ftp.cs.indiana.edu:/pub/faces/>.

Ensuite, les étapes sont :

  1. Créez un bitmap 48x48x1 avec votre outil préféré.
  2. Convertissez le au format "icon" en utilisant xbm2ikon, pbmtoicon, etc., puis compilez le.
  3. cat file.xbm | xbm2ikon |compface > file.face
    
  4. Assurez-vous de quoter ce qui est nécessaire aux chaînes emacs :
    cat ./file.face | sed 's/\\/\\\\/g'  | sed 's/\"/\\\"/g' > ./file.face.quoted
    
  5. Configurez emacs pour inclure le fichier comme un en-tête de courrier -- il y a plusieurs possibilités, soit :
    (setq  mail-default-headers 
      "X-Face:  <chaine de texte affreuse>")
    
    Ou :
    (defun mail-insert-x-face ()
      (save-excursion 
        (goto-char (point-min))
        (search-forward mail-header-separator)
        (beginning-of-line)
        (insert "X-Face:")
        (insert-file-contents "~/.face")))
    
    (add-hook 'mail-setup-hook 'mail-insert-x-face)
    

Cependant 2 choses peuvent poser problème :

Certaines versions de pbmtoicon produisent des lignes d'en-tête non attendues par la version de compface dont je dispose. En ce cas, il faut inclure un tail +3 dans le pipe, de cette façon :

cat file.xbm | xbm2ikon | tail +3 |compface > file.face

Certaines personnes ont aussi remarqué que si l'on utilise la méthode (insert-file), on ne doit PAS quoter la chaîne avec le script sed.

Il peut aussi être pratique d'utiliser le script de Stig <stig@hackvan.com> (inclus dans la distribution de compface à xemacs.org) pour effectuer la conversion. xbm2xface est disponible par FTP anonyme à <URL:ftp://ftp.miranova.com/pub/XEmacs/xbm2xface.pl>.

Contributeurs pour cette partie :

Paul Emsley, Ricardo Marek, Amir J. Katz, Glen McCort, Heinz Uphoff, Peter Arius, Paul Harrison, et Vegard Vesterheim

Comment ajouter de nouveaux répertoires Info ?

Faites quelque chose comme :

(setq Info-directory-list (cons 
			    (expand-file-name "~/info")
 			    Info-default-directory-list))

David Masterson <davidm@prism.kla.com> écrit :

Emacs Info et XEmacs Info font beaucoup de choses différemment. Si vous voulez gérer plusieurs versions d'Emacs, voici quelques points à retenir :

  1. Emacs Info parcourt Info-directory-list de droite à gauche alors que XEmacs la lit de gauche à droite, donc ajoutez à la fin correcte de la liste.
  2. Utilisez Info-default-directory-list pour initialiser Info-directory-list si celle-ci est disponible au démarrage, mais tous les Emacs ne la définissent pas.
  3. Emacs Info recherche un fichier standard `dir' dans chacun des répertoires parcourus à l'étape 1 et les concatène ensemble.
  4. XEmacs Info recherche un fichier `localdir' (consistant uniquement des entrées de menu d'un fichier `dir' dans chacun des répertoires parcourus à l'étape 1 (sauf le premier), les concatène et attache la liste produite à la fin du menu du fichier `dir' dans le premier répertoire.

Une autre possibilité est de convertir la documentation au format HTML avec texi2html et la lire avec un navigateur web comme Lynx ou W3.

Que dois-je modifier pour que l'impression fonctionne ?

Pour l'impression normale, deux variables peuvent être personnalisées.

lpr-command
Elle doit être initialisée avec une commande qui prend l'entrée standard et l'envoie à l'imprimante. Comme :
(setq lpr-command "lp")
lpr-switches
Elle doit être initialisée avec une liste contenant tout ce que la commande d'impression a besoin pour faire son travail. Comme :
(setq lpr-switches '("-depson"))

Pour l'impression Postscript, il existe trois variables analogues à personnaliser :

ps-lpr-command
Elle doit être initialisée avec une commande qui accepte du Postscript sur l'entrée standard et l'envoie à une imprimante Postscript.
ps-lpr-switches
Elle doit être initialisée avec une liste d'options pour que ps-lpr-command fasse son travail.
ps-print-color-p
Cette variable booléenne doit être initialisée à t si l'impression doit être en couleur, sinon à nil.

REMARQUE : Il existe une limitation non documentée dans XEmacs : l'impression Postscript (l'option de menu Pretty Print Buffer) nécessite un environnement fenêtré. Elle ne peut être utilisée en dehors d'X11.


Go to the first, previous, next, last section, table of contents.