glasnost/system/articles/syntax-spip

#language: fr
#title: Règles typographiques de Glasnost : la syntaxe SPIP
#format: spip

{Ces règles typographiques de Glasnost sont tirées de celles de
[SPIP->http://www.uzine.net/spip][[La très grande majorité des raccourcis
typographiques de SPIP s'appliquent sans changement. Toutefois, le moteur de
SPIP ne convenant pas pour Glasnost, il a été complètement réécrit. Certaines
fonctionnalités présentes dans SPIP n'ont pas été (encore ?) implémentées,
d'autres absentes de SPIP ont été ajoutées et certaines règles typographiques
identiques peuvent conduire à de légères différences d'affichage.]]. Cette
documentation est d'ailleurs basée sur celle de SPIP.}

{{{Typographie française}}}

Glasnost ne respecte pas automatiquement la typographie française. C'est le
travail du rédacteur. Par contre, il apporte une aide précieuse sur certains
petits détails. Ainsi il remplace automatiquement les espaces situées avant les
« ((:)) », « ((;)) », « ((!)) » , « ((?)) » et « ((»)) » par des espaces
insécables. Il procède de même pour les espaces situées après les « ((«)) ».


{{{Paragraphes}}}

Pour créer des paragraphes, il suffit de laisser une ligne vide, un peu comme
on sépare les paragraphes dans un email (on « saute » une ligne).

Le fait de simplement « revenir à la ligne » (retour-chariot) sans séparer les
deux paragraphes par une ligne vide ne suffit pas pour provoquer un changement
de paragraphe (cela ne provoque même pas de retour à la ligne).

{{{Gras, italique & caractères de chasse fixe}}}

On indique simplement du texte {en italique} en le plaçant entre des  accolades
simples (« ((\{)) » et « ((\})) ») : « ((...du texte \{en italique\} en...)) ».

On indique du texte {{en gras}} en le plaçant entre des accolades doubles (« ((\{\{)) » et « ((\}\})) ») : « ((...du texte \{\{en gras\}\} en...)) ».

On indique du texte ((en caractères de chasse fixe)) en le plaçant entre des
parenthèses doubles (« ((\(\()) » et « ((\)\))) ») : « ((...du texte \(\(en
caractères de chasse fixe\)\) en...)) ».

{{{Intertitres}}}

Les intertitres sont des titres à l'intérieur d'un texte permettant d'en
indiquer la structure. On les indique très simplement en les plaçant entre des
accolades triples : « ((\{\{\{Un titre de partie\}\}\})) » donnera :  

{{{Un titre de partie}}}

{{{Trait de séparation horizontal}}}

Il est très simple d'insérer un trait de séparation horizontal sur toute la
largeur du texte : il suffit de placer une ligne ne contenant qu'une succession
d'au moins quatre tirets (« ((----)) ») ou soulignés (« ((____)) »), ainsi :

<code>
----
</code>

donnera :
----

{{{Les liens hypertextes}}}

On fabriquera facilement un lien hypertexte avec le code suivant :

<code>
[Glasnost->http://www.entrouvert.org/rubrics.py/2] s'inspire beaucoup de
[SPIP->http://www.uzine.net/spip], qui est une initiative du
[minirézo->http://www.minirezo.net/].
</code>

qui devient « [Glasnost->http://www.entrouvert.org/rubrics.py/2] s'inspire
beaucoup de [SPIP->http://www.uzine.net/spip], qui est une initiative du
[minirézo->http://www.minirezo.net/]. »

L'adresse du lien peut être une adresse absolue (commençant, comme ici, par
« ((http://)) »), une adresse relative (vers une autre page du même site), un
lien vers un document utilisant un protocole de l'internet (« ((ftp://...)) »),
une adresse email (« ((mailto:spam@easter-eggs.com)) »), ...

Le nom du lien (la partie située entre le crochet ouvrant « ((\[)) » et la
flêche « ((->)) » n'est pas obligatoire. S'il est absent, il est remplacé par
l'addresse du lien. Par exemple,

<code>
[Easter-eggs->http://www.easter-eggs.com] est une entreprise détenue et
contrôlée par ses salariés. Code Lutin [->http://www.codelutin.com]) aussi.
</code>

devient : « [Easter-eggs->http://www.easter-eggs.com] est une entreprise
détenue et contrôlée par ses salariés. Théridion ([->http://www.codelutin.com])
aussi. »

{{{Liens hypertextes à l'intérieur du site}}}

Ce même système de liens hypertextes facilite, de plus, la création de liens à
l'intérieur de votre site. La seule subtilité consiste à repérer le numéro de
l'article, de la rubrique, de la brève, etc,  vers laquelle vous voulez mener
votre lien hypertexte .

C'est ce numéro que vous allez indiquer dans le lien hypertexte. Par exemple,
« ((Ce \[lien->article 1\] est un lien vers l'article 1.)) » donne
« Ce [lien->article 1] est un lien vers l'article 1. »

Pour sa part, « ((\[->article 1\])) » affichera le titre de l'article 17 avec
un lien vers cet article : « [->article 1] ».

Pour les élections, les groupes, les images, les personnes, les
rubriques, ..., le principe est le même : il suffit de remplacer le mot
« ((article)) » par « ((election)) » pour les élections, « ((group)) » pour les
groupes, « ((image)) » ou « file » pour les images ou fichiers, « ((person)) »
pour les personnes, « ((rubric)) » pour les rubriques.

Par exemple, « ((\[->image 5\])) » affiche « [->image 5] ».

{{{Ancres (liens vers les titres d'un article}}}

Les titres peuvent être des ancres html. Par exemple :

<code>
[titre qui servira d'exemple->#Titre-exemple]
</code>

est un lien vers l'ancre du titre

<code>
{{{Titre exemple}}}
</code>

{{{Images dans le texte}}}

Plutôt que d'afficher un lien vers une image comme dans l'exemple précédent, il
est souvent préférable d'afficher directement l'image dans le texte.

Pour ce faire, il suffit d'indiquer le numéro ou l'url de l'image entre «
((\<)) » & « ((\>)) », précédée du mot clef « ((image)) ». Par exemple, «
((\<image 5\>)) » donne « <image 5> ». De même « ((\<image
http://www.debian.org/Pics/logo-50.jpg\>)) » donne « <image
http://www.debian.org/Pics/logo-50.jpg> ».

Il est aussi possible de réduire la taille de l'image en indiquant la largeur
souhaitée, suivie d'une astérisque « ((*)) », suivie de la hauteur. Par
exemple, « ((\<image 3 80*60\>)) » donne « <image 3 80*60> ».

{{{Notes de bas de page}}}

Une note de bas de page est, habituellement, signalée par un numéro placé à
l'intérieur du texte, numéro repris en bas de page et proposant un complément
d'information.

Dans Glasnost, cette fonctionnalité (assez lourde à gérer manuellement en HTML)
est automatisée : les notes sont numérotées par Glasnost, qui gère également
des liens hypertextes à l'intérieur du document pour passer directement de
l'appel de note au texte de la note correspondante, et vice-versa.

Une note de bas de page est indiquée, dans Glasnost, en étant placée entre
doubles crochets : « ((Une note\[\[Voici un complément d'information.\]\] de
bas de page.)) » sera affiché sous la forme : « Une note[[Voici un complément
d'information.]] de bas de page. »

{{{Listes ou énumérations}}}

On peut fabriquer des listes de la même manière que dans un email : il suffit
de revenir à la ligne et de commencer la nouvelle ligne avec un tiret (« ((-))
»).

Notez : ici un simple retour à la ligne suffit (on peut faire des énumérations
dans le même paragraphe).

Par exemple,
<code>
- Qu'est-ce que cela peut faire que je lutte pour la mauvaise cause puisque je
  suis de bonne foi ?
- Et qu'est-ce que ça peut faire que je sois de mauvaise foi puisque c'est pour
  la bonne cause.
</code>
{(Jacques Prévert)}

sera affiché ainsi :
- Qu'est-ce que cela peut faire que je lutte pour la mauvaise cause puisque je
  suis de bonne foi ?
- Et qu'est-ce que ça peut faire que je sois de mauvaise foi puisque c'est pour
  la bonne cause.

Il est aussi possible de créer des sous-listes (et des sous-sous-listes...) à
l'intérieur des listes. Il suffit de précéder les tirets du nombre approprié
d'espaces.

Si le tiret est immédiatement suivi d'un des caractères « ((0)) », « ((1)) », «
((2)) », « ((3)) », « ((4)) », « ((5)) », « ((6)) », « ((7)) », « ((8)) », «
((9)) », « ((a)) », « ((A)) », « ((i)) » ou « ((I)) », lui-même suivi d'un
point, chaque élément de la liste sera précédé d'un numéro calculé
automatiquement.

Par exemple,
<code>
- rouge
 - carreau
  -i. 7
  -i. 8
  -i. 9
  -i. 10
  -i. Valet
  -i. Dame
  -i. Roi
  -i. As
 - coeur
- noir
 - pique
 - trèfle
</code>

sera affiché ainsi :

- rouge
 - carreau
  -i. 7
  -i. 8
  -i. 9
  -i. 10
  -i. Valet
  -i. Dame
  -i. Roi
  -i. As
 - coeur
- noir
 - pique
 - trèfle

{{{Tableaux}}}

Pour réaliser des tableaux très simples dans Glasnost, il suffit de faire des
lignes dont les « cases » sont séparées par le symbole « ((\|)) » (pipe, un
trait vertical), lignes commençant et se terminant par des traits verticaux.

Par exemple, le tableau :

|{{Nom}}|{{Prénom}}|{{Âge}}|
|Marso|Ben|23 ans|
|Capitaine||non connu|
|Philant|Philippe|46 ans|
|Cadoc|Bébé|4 mois|

se code ainsi :

<code>
|{{Nom}}|{{Prénom}}|{{Âge}}|
|Marso|Ben|23 ans|
|Capitaine||non connu|
|Philant|Philippe|46 ans|
|Cadoc|Bébé|4 mois|
</code>

{{Note}} : La première ligne du tableau apparaît différemment des autres
lignes, si et seulement si, toutes les cases de la première ligne sont en gras
(i.e. commencent par « ((\{\{)) » et se terminent par « ((\}\})) »).

{{{Caractères spéciaux}}}

Certains caractères ont des rôles particuliers :
- le caractère « ((\\)) » (antislash) indique que le caractère suivant doit
  être préservé, sans chercher à tenir compte de son rôle éventuel.
- le caractère « ((\~)) » (tilde) indique une espace insécable.
- la séquence « ((\\n)) » force un saut de ligne. Cela peut-être utile, par
  exemple à l'intérieur d'une liste ou d'une cellule de tableau.

{{{Court-circuit des raccourcis de Glasnost}}}

Dans certains cas, il peut être utile d'indiquer à Glasnost que certaines
parties d'un document ne doivent pas être « traitées » par le filtre des
raccourcis typographiques et soient considérées comme du HTML pur.

Le code de ce raccourci est : « ((\<html\>texte à ne pas transformer, contenant
un mot en <b>gras</b> ; attention !\</html\>)) », ce qui donne : « <html>texte
à ne pas transformer, contenant un mot en <b>gras</b> ; attention !</html> ».

{{{Code informatique}}}

Certains utilisateurs de Glasnost veulent parfois afficher du code informatique
dans leurs pages. Le raccourci « ((\<code\>...\</code\>)) » est là pour ça. Par
exemple, cet extrait du code source de Glasnost :

<code>
def handle_antislash(self, group):
    character = group[1]
    if character in ['<', '&']:
        return self.handle_htmlEntity(character)
    return character
</code>

a été écrit de la manière suivante :

((\<code\>))
<code>
def handle_antislash(self, group):
    character = group[1]
    if character in ['<', '&']:
        return self.handle_htmlEntity(character)
    return character
</code>
((\</code\>))