<!doctype linuxdoc system>
 <article>
   <title>LinuxDoc+Emacs+Ispell-HOWTO</title>
   <author>
     Auteur : Philippe MARTIN
     (<htmlurl url="mailto:feloy@wanadoo.fr" name="feloy@wanadoo.fr">)
   </author>
   <date>v0.5, 28 Avril 1998</date>
   
   <abstract> 
    Ce document s'adresse aux traducteurs et r&eacute;dacteurs de HOWTO Linux ou de
    toute autre documentation du Projet de Documentation Linux. Il donne &agrave; ces
    derniers des trucs et astuces pour l'utilisation entre autre d'Emacs et
    d'Ispell.
   </abstract>
  <toc>
  
  <sect>Pr&eacute;ambule
   <sect1>Copyright
    <p>
     Copyright Philippe Martin 1998&nl;
     Vous pouvez redistribuer et/ou modifier ce document selon les conditions de
     la GNU General Public Licence, version 2 ou ult&eacute;rieure.
     
   <sect1>Remerciements
    <p>
     Je remercie tout particuli&egrave;rement S&eacute;bastien Blondeel pour m'avoir pos&eacute;
     tant de questions si pertinentes sur la configuration d'Emacs, questions
     qui m'ont permises de concr&eacute;tiser mes connaissances sur le sujet et de vous
     en faire part.
     
   <sect1>Remarques
    <p>
     N'h&eacute;sitez pas &agrave; me faire parvenir toute remarque et/ou critique sur ce
     document, je les examinerai afin de faire &eacute;voluer au mieux ce
     document.&nl;
     N'h&eacute;sitez pas non plus &agrave; me poser des questions relatives au sujet trait&eacute;
     dans cet HOWTO, j'y r&eacute;pondrai avec un int&eacute;r&ecirc;t tout particulier.
     
   <sect1>Versions
    <p>
     Ce document traite des versions suivantes&nbsp;:
	    <itemize>
	     <item>Sgml-tools version 0.99,
	      <item>Emacs version 19.34,
      <item>Ispell version 3.1,
       <item>Toutes les biblioth&egrave;ques Emacs auxquelles je fais r&eacute;f&eacute;rence sont
      celles distribu&eacute;es avec la version d'Emacs pr&eacute;cit&eacute;e, sauf <tt/iso-sgml/
      distribu&eacute;e avec XEmacs et <tt/psgml/ distribu&eacute;e seule.
     </itemize>
     
  <sect>Introduction
   <sect1>Le langage SGML
    <p>
     Le langage <bf>SGML</bf> (<it>Standard Generalized Markup Language</it>)
     est un langage qui permet de d&eacute;finir des types de documents.
    <p>
     On peut par exemple d&eacute;finir gr&acirc;ce &agrave; lui un type de document <it>recette de
      cuisine</it>, qui pr&eacute;cisera qu'il faudra y inclure une premi&egrave;re partie avec
     les diff&eacute;rents ingr&eacute;dients, puis une deuxi&egrave;me avec les accessoires, une
     troisi&egrave;me donnant la fa&ccedil;on de faire votre g&acirc;teau pas &agrave; pas, et enfin une
     belle photo qui montre le r&eacute;sultat final.
    <p>     
     Cette d&eacute;finition d'un type de document est appel&eacute; <bf>DTD</bf>
     (<it>Document Type Definition</it>). Elle ne permet pas de d&eacute;finir quelle
     sera l'allure du document final, mais seulement ce qu'il contiendra ou
     pourra contenir.
    <p>     
     Pour reprendre l'exemple pr&eacute;c&eacute;dent, je suis s&ucirc;r qu'en lisant l'id&eacute;e que je
     me fais d'une recette de cuisine, vous avez reconnu celles que vous ou
     votre cuistot attitr&eacute; utilisez. Et pourtant, elles ont une allure
     compl&egrave;tement diff&eacute;rente&nbsp;: les miennes ont une photo qui se trouve en
     haut &agrave; gauche du placard de la salle de bain, et la liste des ingr&eacute;dients
     se trouve entre les bouteilles de lait et de gaz au fond du jardin. Et les
     v&ocirc;tres&nbsp;?
    <p>     
     Gr&acirc;ce &agrave; cette d&eacute;finition type, quelqu'un peut &eacute;crire son document, sans
     tenir compte de la forme qu'il aura quand il arrivera devant les yeux du
     lecteur. 

   </sect1>
   
   <sect1>La d&eacute;finition du type <tt>LinuxDoc</tt>
    <p>
     Ce type permet d'&eacute;crire, vous l'aviez devin&eacute;, des documents se reportant &agrave;
     Linux.
    <p>
     Ces documents sont en g&eacute;n&eacute;ral construits ainsi&nbsp;: ils commencent par un
     titre suivi de l'auteur, de la date de diffusion et de la version de ce
     document. Suit juste apr&egrave;s un court paragraphe qui explique bri&egrave;vement ce
     que contient ce document (ce qui &eacute;vite d'attendre de l'avoir fini pour se
     rendre compte que ce n'est pas du tout ce que l'on recherchait) puis une
     table des mati&egrave;res qui montre plus en d&eacute;tail son contenu et permet aux plus
     press&eacute;s d'aller voir directement ce qu'ils cherchent.
    <p>
     Et vient ensuite une suite de chapitres, sections, paragraphes. Au milieu
     de ces paragraphes, on peut ins&eacute;rer des morceaux de programme, ou changer
     de police de caract&egrave;res pour faire ressortir un mot ou un passage, ou
     encore y ins&eacute;rer des listes, faire r&eacute;f&eacute;rence &agrave; une autre partie du
     document, et d'autres choses encore.
    <p>
     Pour &eacute;crire un tel document, il suffit alors de pr&eacute;ciser au bon moment le
     titre, l'auteur, la date et la version du document, puis les chapitres et
     sections, dire quand il faut ins&eacute;rer une liste et quels en sont les
     &eacute;l&eacute;ments, et ainsi de suite.

   </sect1>

   <sect1>Les <tt>SGML-Tools</tt>
    <p>
     Les <bf>SGML-Tools</bf> permettent, &agrave; partir de cette sp&eacute;cification du
     document, d'obtenir le document final dans le format que vous pr&eacute;f&eacute;rez. Si
     vous voulez l'ajouter &agrave; votre biblioth&egrave;que personnelle, ce sera s&ucirc;rement du
     <it>PostScript</it>, si vous voulez le faire partager au reste de la
     plan&egrave;te &agrave; travers le Web,  pourquoi pas du <it>HTML</it>, ou si vous
     craquez et voulez le lire sous Windows, vous pouvez toujours l'avoir
     en <it>RTF</it> pour pouvoir le lire sous n'importe quel &eacute;diteur de
     texte. Ou peut-&ecirc;tre sous chacun de ces formats, si vous avez des humeurs
     changeantes.

     La distribution SGML-Tools peut &ecirc;tre r&eacute;cup&eacute;r&eacute;e via FTP anonyme dans
     le r&eacute;pertoire <htmlurl url="ftp://ftp.lip6.fr/pub/sgml-tools/" 
      name ="ftp://ftp.lip6.fr/pub/sgml-tools/">
     
   </sect1>

  <sect>Votre premier document
   <sect1>Depuis un document au format texte
    <p>
     Si vous poss&eacute;dez un document au format texte que vous d&eacute;sirez formater en
     SGML pour ensuite le transformer en divers formats, voici la marche &agrave;
     suivre&nbsp;:

     <enum>
      <item>
       Ajoutez au tout d&eacute;but du fichier les lignes suivantes&nbsp;:
       
       <verb>
	<!doctype linuxdoc system>
        <article>
        <title>le titre ici&etago;title>
        <author>
	le nom de l'auteur, son email
	&etago;author>
        <date>
	la version et la date du document
	&etago;date>
       </verb>
       
      <item>
       S'il y a au tout d&eacute;but du document un court paragraphe qui d&eacute;crit
       bri&egrave;vement le contenu de ce document, encadrez ce paragraphe avec les
       balises <tt>&lt;abstract&gt;</tt> et <tt>&etago;abstract&gt;</tt>.
       
      <item>
       Ajoutez juste &agrave; la suite la balise <tt>&lt;toc&gt;</tt>, qui ins&egrave;re
       automatiquement la table des mati&egrave;res.

      <item>
       Au d&eacute;but de chaque nouveau chapitre, remplacez la ligne contenant le
       num&eacute;ro et le titre du chapitre par&nbsp;:

       <verb>
       <sect>le titre du chapitre
       </verb>
       et rajoutez la balise <tt>&etago;sect&gt;</tt> &agrave; la fin du chapitre.&nl;

	<bf>Note&nbsp;:</bf> Il n'est pas n&eacute;cessaire d'indiquer le num&eacute;ro du
	chapitre, car ils sont num&eacute;rot&eacute;s automatiquement.
	
      <item>
       Faites la m&ecirc;me chose pour les sections, en rempla&ccedil;ant le num&eacute;ro et le
       titre par <tt>&lt;sect1&gt;</tt> et en rajoutant
       <tt>&etago;sect1&gt;</tt> &agrave; la fin de la section. 

       <item>
       Il est possible de cr&eacute;er des sous-sections jusqu'au niveau 4 (avec
       <tt>&lt;sect4&gt;</tt> et <tt>&etago;sect4&gt;</tt>) en op&eacute;rant de la
       m&ecirc;me mani&egrave;re.

      <item>
       &Agrave; chaque d&eacute;but de paragraphe, ajoutez la balise <tt>&lt;p&gt;</tt>.

      <item>
       Si vous d&eacute;sirez mettre en valeur certains mots ou certaines phrases,
       entourez-les des balises <tt>&lt;it&gt;</tt> et <tt>&etago;it&gt;</tt>
       (<it>italique</it>), ou <tt>&lt;bf&gt;</tt> et <tt>&etago;bf&gt;</tt>
       (<bf>gras</bf>), ou encore <tt>&lt;tt&gt;</tt> et <tt>&etago;tt&gt;</tt>
       (<tt>caract&egrave;res de machine &agrave; &eacute;crire d'antan</tt>).

      <item>
       Lorsqu'une liste appara&icirc;t dans le texte, comme celle-ci par exemple&nbsp;:

       <verb>
	Voici une liste :

	- d'une ligne,
	- ah non, deux,
	- tiens, trois,
	- c'est tout.

	de quatre lignes !
       </verb>
       
       il faut la remplacer par&nbsp;:
       
       <verb>
	Voici une liste :
       <itemize>
       <item>d'une ligne,
       <item>ah non, deux,
       <item>tiens, trois,
       <item>c'est tout.
	&etago;itemize>
	de quatre lignes !
       </verb>
       
      <item>
       Lorsqu'un bloc repr&eacute;sente une partie de programme, ou autre chose que
       l'on veut faire ressortir&nbsp;:

       <verb>
       <verb>
	10 REM Tiens qu'est-ce que c'est ?
	20 REM Je croyais que ca n'existait plus !
	30 PRINT "Je suis de retour ";
	40 PRINT "pour sauver le monde."
	50 INPUT "Des mains de qui d'apr&egrave;s toi ?",M$
	60 IF M$="Bill" THEN PRINT "Tu es un sage":GOTO AUPARADIS
	70 ELSE PRINT "Tu n'as rien compris...":GOTO AUPAYSDUDOLLAR
	&etago;verb>
       </verb>
       
      <item>
       Arriv&eacute; &agrave; ce point, vous avez d&eacute;j&agrave; bien avanc&eacute; votre formatage en
       SGML. Vous pourrez, si vous voulez affiner votre document, jeter un oeil
       sur le guide d'utilisation des <bf>SGML-Tools</bf>, qui d&eacute;crit plus en
       d&eacute;tail le type de document <bf>LinuxDoc</bf>.

     </enum>
   </sect1>
  </sect>

  <sect>Configurer <tt>Emacs</tt>
   <sect1>Les caract&egrave;res accentu&eacute;s
    <p>
     Si vous d&eacute;sirez &eacute;crire des documents en fran&ccedil;ais ou dans une autre langue
     europ&eacute;enne, vous aurez besoin de caract&egrave;res accentu&eacute;s. Voici comment
     configurer Emacs pour qu'il accepte ces caract&egrave;res.

    <sect2>L'affichage des caract&egrave;res 8 bits
     <p>
      Pour qu'Emacs soit capable d'afficher des caract&egrave;res 8 bits, ajoutez les
      lignes suivantes &agrave; votre <tt>.emacs</tt>&nbsp;:
      <verb>
       (standard-display-european 1)
       (load-library "iso-syntax")
      </verb>

      Si vous utilisez Emacs sur un terminal qui ne supporte pas l'affichage
      des caract&egrave;res 8 bits, vous pouvez utiliser la biblioth&egrave;que
      <tt>iso-ascii</tt> (<tt>(load-library "iso-ascii")</tt>), qui permet &agrave;
      Emacs d'afficher les caract&egrave;res 8 bits d'une fa&ccedil;on approch&eacute;e.

    <sect2>La saisie des caract&egrave;res accentu&eacute;s
     <p>
      Si votre clavier permet de taper les caract&egrave;res accentu&eacute;s, aucun probl&egrave;me
      ne devrait se poser. En revanche, s'il ne le permet pas, voici quelques
      moyens d'y rem&eacute;dier&nbsp;:

     <sect3>La biblioth&egrave;que <tt>iso-acc</tt>
      <p>
       La biblioth&egrave;que <tt>iso-acc</tt> d'Emacs permet d'entrer des caract&egrave;res
       accentu&eacute;s malgr&eacute; que l'on ait un clavier qui ne le permette a priori pas.
      <p>
       Pour utiliser cette biblioth&egrave;que, ajoutez la ligne suivante &agrave; votre
       <tt>.emacs</tt>&nbsp;:
       <verb>
	(load-library "iso-acc")
       </verb>
      <p>
       Puis, une fois avoir relanc&eacute; Emacs et ouvert le fichier que vous voulez
       &eacute;diter, tapez <tt>Meta-x iso-accents-mode</tt>.
      <p>
       Vous pouvez alors entrer un caract&egrave;re <bf>&eacute;</bf> en tapant <bf>'</bf> puis
       <tt>e</tt>. De mani&egrave;re g&eacute;n&eacute;rale, on peut entrer un caract&egrave;re accentu&eacute; en
       tapant d'abord l'accent, puis la lettre &agrave; accentuer (aussi bien minuscule
       que majuscule). Voici les diff&eacute;rents accents utilisables&nbsp;:
       
       <list>
	<item><tt>'</tt>&nbsp;: Un accent aigu
	<item><tt>`</tt>&nbsp;: Un accent grave
	<item><tt>^</tt>&nbsp;: Un accent circonflexe
	<item><tt>"</tt>&nbsp;: Un tr&eacute;ma
	<item><tt>&tilde;</tt>&nbsp;: Un tilde au dessus de la lettre, une
	c&eacute;dille lorsqu'il pr&eacute;c&egrave;de un c, et d'autres encore (voir fichier iso-acc.el),
	<item><tt>/</tt>&nbsp;: Pour barrer une lettre, ...
       </list>      
       
       Si vous avez besoin d'entrer un de ces caract&egrave;res et non pas une lettre
       accentu&eacute;e, tapez un espace &agrave; la suite de l'accent. Par exemple, pour taper
       <it>l'&eacute;l&eacute;phant</it>, tapez <tt>l ' <cparam/spc/ ' e l ' e ...</tt>
      <p>
       Vous pouvez trouver l'ensemble des combinaisons dans le fichier
       <tt>iso-acc.el</tt>.

     <sect3>La touche <cparam/Meta/
      <p>
       Il est possible avec certains terminaux de saisir des caract&egrave;res accentu&eacute;s
       gr&acirc;ce &agrave; la touche <cparam/Meta/ (ou <cparam/Alt/). Par exemple, la frappe
       de <bf><cparam/Meta/-i</bf> permet d'entrer le caract&egrave;re <bf>&eacute;</bf>.
      <p>
       Mais Emacs pr&eacute;voit la touche <cparam/Meta/ pour d'autres utilisations.
       Il faut donc taper la s&eacute;quence <bf/Ctrl-q/ (commande <tt/quoted-insert/)
       avant de taper <bf><cparam/Meta/-i</bf>.
       <p>
       Cette commande permet aussi d'entrer un caract&egrave;re selon son code en
       octal. Tapez <bf/Ctrl-q/ suivi du code en octal du caract&egrave;re que vous
       d&eacute;sirez entrer.
 
    <sect2>Afficher les caract&egrave;res SGML en 8 bits
     <p>
      En SGML, les caract&egrave;res accentu&eacute;s peuvent &ecirc;tre tap&eacute;s gr&acirc;ce &agrave; des
      macros. Par exemple, le caract&egrave;re <bf/&eacute;/ s'&eacute;crit <bf/&amp;eacute;/. En
      g&eacute;n&eacute;ral, les applications qui lisent du SGML arrivent &agrave; lire les
      caract&egrave;res 8 bits et il n'est donc pas n&eacute;cessaire d'utiliser ces
      macros. Mais il est possible que certaines ne le puissent pas. En sachant
      qu'il existe un moyen facile de rem&eacute;dier &agrave; &ccedil;a, ce serait dommage de faire
      "planter" ces derni&egrave;res applications. 
     <p>
      En effet, la biblioth&egrave;que <tt>iso-sgml</tt> vous permet d'entrer sous
      Emacs des caract&egrave;res accentu&eacute;s, comme d'habitude, mais lorsqu'il
      enregistre votre fichier, il transforme tous ces caract&egrave;res 8 bits par
      leur &eacute;quivalent SGML.
     <p>
      Il est donc tr&egrave;s facile, gr&acirc;ce &agrave; cette biblioth&egrave;que, de saisir et relire
      votre document sous Emacs, et vous &ecirc;tes s&ucirc;r que votre document ne sera pas
      rejet&eacute; par une application qui ne comprend pas les caract&egrave;res 8 bits.
     <p>
      Pour utiliser cette biblioth&egrave;que, il suffit de rajouter ces lignes &agrave; votre
      <tt>.emacs</tt>&nbsp;:

      <verb>
       (setq sgml-mode-hook
       '(lambda () "D&eacute;fauts pour le mode SGML."
       (load-library "iso-sgml")))
      </verb>
      
   <sect1>Le mode SGML
     <p>
     Lorsque vous ouvrez un fichier avec une extension <bf>.sgml</bf>, Emacs
     lance normalement le <bf>mode sgml</bf>. S'il ne le fait pas, vous pouvez
     soit le faire manuellement avec <tt>Meta-x sgml-mode</tt>, soit le lancer
     automatiquement en rajoutant ces lignes &agrave; votre <tt>.emacs</tt>&nbsp;:

     <verb>
      (setq auto-mode-alist
      (append '(("\.sgml$"  . sgml-mode))
                auto-mode-alist))
     </verb>

     Ce mode permet par exemple de choisir comment ins&eacute;rer les caract&egrave;res 8
     bits. En utilisant <tt>Meta-x sgml-name-8bit-mode</tt> (ou dans le menu
     <it>SGML/Toggle 8 bit insertion</it>), vous pouvez choisir d'ins&eacute;rer les
     caract&egrave;res 8 bits soit tels quels, soit sous leur forme SGML, c'est-&agrave;-dire 
     sous la forme <bf>&amp;...;</bf>.

     Il permet aussi de cacher ou non les balises SGML, avec <tt>Meta-x
     sgml-tags-invisible</tt> ou le menu <it>SGML/Toggle Tag Visibility</it>. 

   <sect1>Le mode PSGML
    <p>
     Le mode PSGML donne de grandes facilit&eacute;s pour &eacute;diter des documents SGML
     sous Emacs.
    <p>
     La documentation <htmlurl name="psgml-linuxdoc"
      url="http://www.linux-france.com/article/psgml-linuxdoc">
     explique comment installer et utiliser ce mode conjointement avec
     <it>LinuxDoc</it>. 

   <sect1>Divers
    <sect2>Le mode auto-fill
     <p>
      En mode normal, lorsque vous tapez un paragraphe et que vous arrivez en
      bout de ligne, vous devez vous-m&ecirc;me utiliser la touche <cparam/Entr&eacute;e/
      pour revenir &agrave; la ligne, ou bien votre ligne continue ind&eacute;finiment tout le
      long du paragraphe. Il en r&eacute;sulte, si vous utilisez <cparam/Entr&eacute;e/ pour
      revenir &agrave; la ligne, un paragraphe dont les fins de lignes ne sont pas
      align&eacute;es, et en g&eacute;n&eacute;ral ces lignes rallongent ou raccourcissent au fur et
      &agrave; mesure. De m&ecirc;me si vous laissez des lignes d&eacute;passer une longueur
      raisonnable, vous ne pourrez pas les voir sous certains &eacute;diteurs.
     <p>
      Le mode <bf>auto-fill</bf> permet d'automatiser cette t&acirc;che ingrate&nbsp;:
      lorsque vous d&eacute;passez une certaine colonne (la 70e par d&eacute;faut), il vous
      place automatiquement &agrave; la ligne suivante.
     <p>
      Voici comment utiliser ce mode, et fixer la largeur de vos lignes &agrave; 80&nbsp;:

      <verb>
       (setq sgml-mode-hook
       '(lambda () "D&eacute;fauts pour le mode SGML."
       (auto-fill-mode)	
       (setq fill-column 80)))
      </verb>

   <sect>Ispell
    <p>
     Si vous d&eacute;sirez v&eacute;rifier l'orthographe de votre document directement depuis
     Emacs, vous pouvez utiliser la distribution <bf>Ispell</bf> et son mode
     associ&eacute; sous Emacs.

    <sect1>Configuration initiale
    <p>
     Tout d'abord, ajoutez ces lignes &agrave; votre <tt>.emacs</tt> pour
     configurer Emacs&nbsp;:

     <verb>
      (autoload 'ispell-word "ispell"
         "Check the spelling of word in buffer." t)
      (global-set-key "\e$" 'ispell-word)
      (autoload 'ispell-region "ispell"
         "Check the spelling of region." t)
      (autoload 'ispell-buffer "ispell"
         "Check the spelling of buffer." t)
      (autoload 'ispell-complete-word "ispell"
         "Look up current word in dictionary and try to complete it." t)
      (autoload 'ispell-change-dictionary "ispell"
         "Change ispell dictionary." t)
      (autoload 'ispell-message "ispell"
         "Check spelling of mail message or news post.")
      (autoload 'ispell-minor-mode "ispell"
         "Toggle mode to automatically spell check words as they are typed in.")
      </verb>

     <p>

    <sect1>Le choix de vos dictionnaires par d&eacute;faut
     <p>
      Vous pouvez configurer Emacs pour qu'&agrave; l'ouverture d'un fichier, celui-ci
      choisisse automatiquement quels dictionnaires utiliser. Vous pouvez en
      effet utiliser plusieurs dictionnaires. Le premier et s&ucirc;rement le plus
      important est le dictionnaire principal, distribu&eacute; avec Ispell. Vous avez
      le choix entre plusieurs langues. Le deuxi&egrave;me est votre dictionnaire
      personnel, celui o&ugrave; Ispell ajoutera les mots qu'il n'aura pas trouv&eacute; dans
      le premier dictionnaire mais que vous lui aurez indiqu&eacute; de garder.

      Voici les lignes &agrave; ins&eacute;rer &agrave; votre <tt>.emacs</tt> si vous d&eacute;sirez
      utiliser par d&eacute;faut le dictionnaire fran&ccedil;ais distribu&eacute; avec Ispell, et
      placer votre dictionnaire personnel dans un fichier <tt>.ispell-dico-perso</tt>
      dans votre r&eacute;pertoire racine.

      <verb>
       (setq sgml-mode-hook
      '(lambda () "D&eacute;fauts pour le mode SGML."
      (setq ispell-personal-dictionary "~/.ispell-dico-perso")
      (ispell-change-dictionary "francais")
       ))
       </verb>

   <sect1>Choix des dictionnaires pour un certain fichier
     <p>
     Un petit probl&egrave;me se pose si vous ne v&eacute;rifiez pas toujours des textes dans la
     m&ecirc;me langue. Et si vous traduisez des documents, il est probable que vous
     passiez d'une langue &agrave; l'autre assez souvent. 

    <p>
     Je ne connais pas de moyen en Lisp de choisir, soit automatiquement, soit en
     un <em/click/ de souris, les dictionnaires principaux et personnels associ&eacute;s
     &agrave; la langue utilis&eacute;e dans le fichier en cours. (Si vous en connaissez un,
     faites-moi signe !)

     <p>
     Mais il est possible d'indiquer quels dictionnaires vous voulez utiliser
     pour ce fichier (et seulement celui-l&agrave;). Il suffit de les rajouter
     en commentaire, &agrave; la fin du fichier, pour qu'Ispell puisse les lire
     en lan&ccedil;ant une v&eacute;rification&nbsp;:

     <verb>
      <!-- Local IspellDict: english -->
      <!-- Local IspellPersDict: ~/emacs/.ispell-english -->
     </verb>

      Si vous avez d&eacute;fini dans votre <tt/.emacs/ que vos dictionnaires par d&eacute;faut
      seront fran&ccedil;ais, vous pouvez alors ajouter ces lignes &agrave; chaque fin de
      fichier dont le texte est en anglais.

    <sect1>V&eacute;rifier votre document
      <p>
      Pour lancer la v&eacute;rification de votre document en int&eacute;gralit&eacute;, utilisez, depuis
      n'importe o&ugrave; dans votre document <tt>Meta-x ispell-buffer</tt>. Vous pouvez
      aussi lancer la v&eacute;rification sur une r&eacute;gion seulement du document&nbsp;:

      <itemize>
       <item>Indiquez le d&eacute;but de la r&eacute;gion avec <tt>Ctrl-Spc</tt>
	(mark-set-command),
       <item> Placez-vous &agrave; la fin de la r&eacute;gion &agrave; v&eacute;rifier,
       <item> tapez <tt>Meta-x ispell-region</tt>.
      </itemize>
      
      Emacs lance alors Ispell. Si ce dernier trouve un mot qu'il ne connait pas,
      il vous indique ce mot (normalement en surbrillance) et vous demande de
      presser une touche&nbsp;:
      
      <itemize>
       <item><bf>spc </bf>accepte ce mot, uniquement pour cette fois,
       <item><bf>i </bf>accepte ce mot et l'ins&egrave;re dans votre dictionnaire
       personnel, 
       <item><bf>a </bf>accepte ce mot pour cette session,
       <item><bf>A </bf>accepte ce mot pour ce fichier, en l'ins&eacute;rant dans le
       dictionnaire local au fichier,
       <item><bf>r </bf>permet de corriger le mot mal orthographi&eacute;,
       <item><bf>R </bf>permet de corriger toutes les occurrences du mot mal
       orthographi&eacute;,
       <item><bf>x </bf>arr&ecirc;te la v&eacute;rification, et replace le curseur &agrave; sa
       position initiale,
       <item><bf>X </bf>arr&ecirc;te la v&eacute;rification en laissant le curseur sur le mot
       mal orthographi&eacute;, vous permettant de modifier votre fichier&nbsp;; vous pouvez
       continuer la v&eacute;rification en tapant <tt>Meta-x ispell-continue</tt>,
       <item><bf>? </bf>affiche une aide en ligne.
      </itemize>

      Si Ispell trouve un ou plusieurs mots ressemblant &agrave; celui qu'il ne connait
      pas, il vous les indique dans une petite fen&ecirc;tre, chacun pr&eacute;c&eacute;d&eacute; d'un
      chiffre. Il suffit de presser un de ces chiffres pour corriger le mot mal
      orthographi&eacute; par le mot correspondant.

    <sect1>Dictionnaire personnel contre dictionnaire local au fichier
      <p>
      La touche <bf>i</bf> permet d'ins&eacute;rer un mot dans le dictionnaire
      personnel, alors que la touche <bf>A</bf> permet d'ins&eacute;rer un mot dans le
      dictionnaire local au fichier.

      <p>
      Le dictionnaire local au fichier est une suite de mots ins&eacute;r&eacute;s &agrave; la fin du
      fichier, sous forme de commentaires, et qui est relu par Ispell chaque
      fois que vous le lancez sur ce fichier. Cela permet d'accepter certains
      mots, valables dans ce fichier, mais qui ne le seraient pas dans
      d'autres.

      <p>
      A mon avis, il est pr&eacute;f&eacute;rable que le dictionnaire personnel soit
      r&eacute;serv&eacute; aux mots que le dictionnaire principal ne connait pas mais qui
      font vraiment partie de la langue (comme les mots compos&eacute;s), plus
      certains mots n'appartenant pas &agrave; la langue ou noms propres qui reviennent
      dans un grand nombre de fichiers (comme <it>Linux</it>) et ne ressemblant pas
      trop &agrave; un mot du dictionnaire principal&nbsp;: l'ajout par exemple de certains
      noms et pr&eacute;noms de personnes dans le dictionnaire personnel peut &ecirc;tre
      dangereux, car ils ressemblent parfois &agrave; un mot de la langue
      (imaginez qu'il ne trouve pas de fautes dans la phrase&nbsp;: `<it>Ted en est
      l'effet au phil du temps.'</it> !).

      <sect1>La v&eacute;rification `&agrave; la vol&eacute;e'
      <p>
      Ispell peut aussi v&eacute;rifier l'orthographe au fur et &agrave; mesure que vous tapez
      votre document. Il faut utiliser pour cela le mode
      <bf>ispell-minor-mode</bf>. Lorsque vous d&eacute;sirez lancer ou arr&ecirc;ter ce mode
      de v&eacute;rification, tapez <tt>Meta-x ispell-minor-mode</tt>. Ispell vous
      envoie alors un <it>bip</it> chaque fois que vous tapez un mot qu'il ne
      connait pas. 

      <p>
      Si ces <it>bip</it> &agrave; r&eacute;p&eacute;tition vous ennuient (ou si votre voisin de
      palier dort !), vous pouvez les remplacer par un flash de l'&eacute;cran, en
      tapant <tt>Meta-x set-variable RET visible-bell RET t RET</tt>. Ou ajoutez
      cette ligne &agrave; votre <tt>.emacs</tt> pour faire taire Emacs &agrave; tout jamais&nbsp;:

      <verb>
       (setq visible-bell t)
      </verb>

   <sect1>Saut de r&eacute;gions
    <p>
     Il est possible de ne pas v&eacute;rifier votre document en int&eacute;gralit&eacute;, en
     sautant quelques r&eacute;gions bien sp&eacute;cifiques. En effet, vous voudrez s&ucirc;rement
     ne pas v&eacute;rifier l'orthographe de vos balises SGML. Pour cela, ajoutez la
     ligne suivante &agrave; votre <tt>.emacs</tt>&nbsp;:

     <verb>
      (setq ispell-skip-sgml t)  
     </verb>

     Une version Beta du 20 Mars 98  du fichier <tt>ispell.el</tt> est disponible
     &agrave; l'adresse <htmlurl url="http://kdstevens.com/~stevens/ispell-page.html"
      name="http://kdstevens.com/~stevens/ispell-page.html">. Cette version
     &eacute;tend les r&eacute;gions SGML &agrave; sauter. En effet, la version d'<tt/ispell.el/
     fournie avec Emacs permet seulement de sauter les tags SGML, de la forme
     <bf>&lt;tt&gt;</bf> ou <bf>&lt;/tt&gt;</bf>.
     

     Cette version Beta permet de sauter &eacute;galement les r&eacute;gions entre&nbsp;:

     <itemize>
      <item>&lt;author&gt; et la fin de la ligne,
      <item>&lt; et / (pour les tags SGML de la forme <bf>&lt;em/.../</bf>,
      <item>&lt;code&gt; et &lt;/code&gt;,
      <item>&lt;verb&gt; et &lt;/verb&gt;,
      <item>&lt;tt&gt; et &lt;/tt&gt;.
     </itemize>
     
  <sect>Pour aller plus loin
   <sect1>Insertion automatique d'une ent&ecirc;te
    <p>
     Sous Emacs, il est possible d'<em>accrocher</em> des actions &agrave; chaque
     &eacute;v&eacute;nement (ouverture d'un fichier, sauvegarde, lancement d'un mode, etc).

    <p>
     La biblioth&egrave;que <bf>autoinsert</bf> utilise cette fonctionnalit&eacute;&nbsp;:
     lorsque vous ouvrez un nouveau fichier sous Emacs, cette biblioth&egrave;que
     ins&egrave;re, selon le type de ce fichier, une ent&ecirc;te <em>standard</em>.

    <p>
     Dans notre cas, cette ent&ecirc;te <em>standard</em> pourrait bien &ecirc;tre la partie qui
     d&eacute;clare le type de document (LinuxDoc), le titre, l'auteur et la date.

    <p>
     Je vais d&eacute;crire ici deux fa&ccedil;ons d'ins&eacute;rer une telle ent&ecirc;te.
     Soit en ins&eacute;rant un fichier que vous aurez pr&eacute;alablement
     &eacute;crit, soit en lan&ccedil;ant une routine &eacute;crite en <bf>elisp</bf>.

   <sect2>par l'insertion d'un fichier
    <p>
     Il faut tout d'abord pr&eacute;ciser &agrave; Emacs d'ex&eacute;cuter la commande
     <tt>auto-insert</tt> &agrave; l'ouverture d'un fichier, puis lire la biblioth&egrave;que
     <bf>autoinsert</bf> qui d&eacute;clare la liste <tt>auto-insert-alist</tt> qu'il
     nous faut modifier, cette derni&egrave;re d&eacute;finissant pour chaque type de fichier
     l'ent&ecirc;te &agrave; ins&eacute;rer. Le fichier &agrave; ins&eacute;rer doit par d&eacute;faut se trouver dans le
     r&eacute;pertoire <tt>~/insert/</tt>, mais il est possible de red&eacute;finir la variable
     <tt>auto-insert-directory</tt> si l'on veut le placer ailleurs. 

    <p>
     Voici les lignes &agrave; rajouter &agrave; votre <tt>.emacs</tt> pour ins&eacute;rer le fichier
     <tt>~/emacs/sgml-insert.sgml</tt> &agrave; l'ouverture d'un nouveau fichier
     SGML&nbsp;: 

     <verb>
      (add-hook 'find-file-hooks 'auto-insert)
      (load-library "autoinsert")
      (setq auto-insert-directory "~/emacs/")
      (setq auto-insert-alist
            (append '((sgml-mode .  "sgml-insert.sgml"))
                    auto-insert-alist))
      </verb>
     
     Vous pouvez alors &eacute;crire dans le fichier <tt>~/emacs/sgml-insert.sgml</tt>
     votre ent&ecirc;te personnalis&eacute;e, puis relancer Emacs et ouvrir un fichier
     <tt>toto.sgml</tt>. Emacs devrait alors vous demander de confirmer
     l'insertion automatique, et dans l'affirmative ins&eacute;rer votre ent&ecirc;te.

   <sect2>par l'ex&eacute;cution d'une routine
    <p>
     Cela fonctionne un peu comme pr&eacute;c&eacute;demment, mais au lieu de pr&eacute;ciser dans la
     variable <tt>auto-insert-alist</tt> un fichier &agrave; ins&eacute;rer, il faut pr&eacute;ciser
     une fonction &agrave; ex&eacute;cuter. Voici comment proc&eacute;der, en supposant que l'on
     &eacute;crive cette fonction dans un fichier <tt>~/emacs/sgml-header.el</tt>
     (inutile d'encombrer votre <tt>.emacs</tt> avec cette fonction qui peut se r&eacute;v&eacute;ler
     assez longue)&nbsp;:

     <verb>
      (add-hook 'find-file-hooks 'auto-insert)
      (load-library "autoinsert")
      (add-to-list 'load-path "~/emacs")
      (load-library "sgml-header")
      (setq auto-insert-alist
            (append '(((sgml-mode .  "SGML Mode") . insert-sgml-header))
	            auto-insert-alist))
      </verb>

     Vous pourrez trouver en <ref id="insert-sgml-header" name="appendice"> un
     exemple de cette fonction <tt>insert-sgml-header</tt>.

     
  <appendix>

  <sect>Une fonction <tt>insert-sgml-header</tt><label id="insert-sgml-header">
   <p>
    Cette fonction permet &agrave; l'utilisateur d'ins&eacute;rer une ent&ecirc;te personnalis&eacute;e
    pour un document du Projet de Documentation Linux dans un fichier. Elle peut
    soit &ecirc;tre appel&eacute;e automatiquement lorsque l'on ouvre un nouveau fichier
    SGML, soit &ecirc;tre appel&eacute;e explicitement par l'utilisateur.

   <p>
    Cette fonction demande &agrave; l'utilisateur, &agrave; travers le <em>mini-buffer</em>,
    divers renseignements, certains n&eacute;cessaires, d'autres facultatifs.

    Tout d'abord le titre. Si l'utilisateur n'entre aucun titre, la fonction
    retourne imm&eacute;diatement, et rien n'est ins&eacute;r&eacute;. Vient ensuite la date,
    l'auteur, son email et sa home page (ces deux derniers &eacute;tant facultatifs).

    Il demande ensuite le nom du traducteur. S'il n'y a pas de traducteur pour ce
    document, il suffit de presser <em>Entr&eacute;e</em>, et les renseignements
    sur le traducteur ne seront pas demand&eacute;s. Dans le cas contraire, la
    fonction demande l'email et la home page du traducteur (aussi facultatifs).

    Cette fonction affiche alors dans le buffer courant votre ent&ecirc;te, comportant
    bien s&ucirc;r tous les renseignements que vous avez cit&eacute;s mis en forme, mais
    aussi les balises n&eacute;cessaires au paragraphe d'introduction et au premier
    chapitre, puis place le curseur &agrave; l'endroit o&ugrave; vous pourrez saisir le
    paragraphe d'introduction. 

    <verb>
(defun insert-sgml-header ()
  "Ins&egrave;re l'ent&ecirc;te d'un document LinuxDoc"
  (interactive)
  (let (titre auteur email home traducteur email-traducteur home-traducteur date 
	      point-debut)
    (setq titre (read-from-minibuffer "Titre : "))
    (if (> (length titre) 0)
	(progn 
	  (setq date (read-from-minibuffer "Date : ")
		auteur (read-from-minibuffer "Auteur : ")
		email (read-from-minibuffer "Email auteur : ")
		home (read-from-minibuffer "Home page auteur : http://")
		traducteur (read-from-minibuffer "Traducteur : "))
	  (insert "<!doctype linuxdoc system>\n<article>\n<title>")
	  (insert titre)
	  (insert "&etago;title>\n<author>\nAuteur : ") (insert auteur) (insert "&nl;\n")
	  (if (> (length email) 0)
	      (progn
		(insert "<htmlurl url=\"mailto:")
		(insert email) (insert "\" name=\"") (insert email)
		(insert "\">&nl;\n")))
	  (if (> (length home) 0)
	      (progn
		(insert "<htmlurl url=\"http://")
		(insert home) (insert "\" name=\"") (insert home)
		(insert "\">\n&nl;")))
	  (if (> (length traducteur) 0)
	      (progn
		(setq email-traducteur (read-from-minibuffer "Email traducteur : ")
		      home-traducteur (read-from-minibuffer "Home page traducteur : http://"))
		(insert "Traducteur : ") 
		(insert traducteur) 
		(insert "&nl;\n")
		(if (> (length email-traducteur) 0)
		    (progn 
		      (insert "<htmlurl url=\"mailto:") 
		      (insert email-traducteur) (insert "\" name=\"") 
		      (insert email-traducteur)
		      (insert "\">&nl;\n")))
		(if (> (length home-traducteur) 0)
		    (progn 
		      (insert "<htmlurl url=\"http://") 
		      (insert home-traducteur) (insert "\" name=\"")
		      (insert home-traducteur)
		      (insert "\">&nl;\n")))))
	  (insert "&etago;author>\n<date>\n")
	  (insert date)
	  (insert "\n&etago;date>\n\n<abstract>\n")
	  (setq point-debut (point))
	  (insert "\n&etago;abstract>\n<toc>\n\n<sect>\n<p>\n\n\n&etago;sect>\n\n&etago;article>\n")
	  (goto-char point-debut)
	  ))))
 </verb>
 </article>
