Affichage du code PML – 'pml/pmldocimport.pml' :

   1 # Emplacement pour le sommaire

   2 <toc>

   3

   4 <chapitre Avertissement>

   5 #=======================

   6 <p L’outil ici présenté n’est encore qu’en phase de mise au point. Il est donc incomplet et présente forcément des bogues.>

   7 <p Pour ceux qui se plongeront dans le code source, le programme de conversion HTML→ePub est à ce jour une transposition/adaptation en Python d’un module initialement développé en PHP et ajusté au fil des ans. C’est donc encore un sac de nœuds dont j’ai bien conscience qu’il devrait être entièrement réécrit.>

   8 <espace>

   9 <encadré

  10 ———›<p <b L’ensemble du pack proposé est offert en toute liberté. Chacun peut y apporter des modifications et corrections ainsi que le diffuser librement. Je demande juste à ce que me soient communiquées les modifications et corrections qu’il aura apportées (courriel : jean-luc@blary.eu) afin que le plus grand nombre puisse en profiter.>>

  11 ———›<p Tout contributeur sera naturellement crédité de ses interventions dans les évolutions du produit.>

  12 ———›>

  13

  14 <chapitre Préambule>

  15 #===================

  16 <p PML est né de l’idée qu’on pouvait à la fois rendre les documents HTML plus simples, plus lisibles et plus puissants.>

  17 <coché Plus simples, parce qu’en remplaçant le système de balises ouvrantes et fermantes par des balises englobantes, on réduit l’encombrement de celles-ci.>

  18 <coché Plus lisibles, parce que grâce à la réduction de l’encombrement des balises et à un système de métabalises, on se rapproche du texte natif.>

  19 <coché Plus puissants, parce qu’on peut, grâce aux métabalises, utiliser des commandes plus courtes qui en font davantage.>

  20 <espace>

  21 <p Tout fichier HTML est directement convertible en PML et vice-versa.>

  22 <espace>

  23 <p PML est constitué de plusieurs modules distincts :>

  24 <espace_demi>

  25 <p.liste A. Un module de conversion PML ↔ HTML, principalement orienté documents statiques (sites ou parties de site Internet non évolutifs, ePub…) et simplement formé de deux programmes écrits en python 3 :>

  26 <p.liste2 <arialb pmlimport> pour convertir un fichier HTML en PML ;>

  27 <p.liste2 <arialb pmlexport> qui convertit un fichier PML en HTML.>

  28 <p Plus un troisième module, réservé à la création de livres numériques :>

  29 <p.liste2 <arialb htmlepub> qui convertit un fichier HTML en un ePub (ePub2 ou ePub3).>

  30 <espace_demi>

  31 <p.liste B. Un module de gestion des documents PML en tant que pages internet. Il permet de s’affranchir complètement du HTML et de créer ses pages directement en PML, avec l’avantage en plus de la possibilité d’appeler des routines en Python pour compléter les pages, remplaçant là PHP et Python « pur » (ainsi que ASP/IIS sur les serveurs Windows puisque PML est multiplateformes).>

  32 <espace_demi>

  33 <p.liste C. Un outil de gestion de bases de données, <arialb pymyadmin>, qui doit remplacer avantageusement <arial phpmyadmin> (car plus léger et plus performant, notamment grâce à beaucoup moins de javascript) pour l’écrasante majorité des fonctionnalités réellement utiles. <rouge (Développement en cours.)>>

  34 <espace_demi>

  35 <p.liste D. En principe, il y aura aussi un CMS (<i Content Management System> ou Système de Gestion de Contenu) destiné à mettre en œuvre et gérer des sites Internet complets. Également écrit en python 3, il est entièrement interfacé en mode navigateur et stocke la quasi-totalité des données dans une base MySQL ou compatible (ex. MariaDB). Toutefois, il est possible que j’abandonne cette voie (même si l’outil existe et est opérationnel, nécessitant toutefois encore pas mal de tests et débogage), le module pml mentionné en B. ci-dessus étant extrêmement prometteur et beaucoup plus simple.>

  36 <espace>

  37 <p Les premiers chapitres de cette documentation décrivent le principe du « langage » PML. Les autres modules sont (ou seront) détaillés dans les chapitres suivants. >

  38

  39 <chapitre 1. Présentation générale>

  40 #==================================

  41

  42 <p Le principe de base de PML consiste à remplacer le groupe>

  43 <code \<balise\>texte\</balise\>>

  44 <p par>

  45 <code \<balise texte\>>

  46 <p le texte pouvant lui-même contenir des balises.>

  47 <espace_demi>

  48 <p <u Exemple 1 :>>

  49 <p Ce tableau basique de 2 lignes de 2 colonnes s’écrit en HTML :>

  50 <code \<table\>\<tr\>\<td\>A1\</td\>\<td\>B1\</td\>\</tr\>\<tr\>\<td\>A2\</td\>\<td\>B2\</td\>\</tr\>\</table\>>

  51 <p En PML, il devient :>

  52 <code \<table \<tr \<td A1\>\<td B1\>\>\<tr \<td A2\>\<td B2\>\>\>>

  53 <p N’est-ce pas plus court et sensiblement plus lisible ?>

  54 <espace_demi>

  55 <p <u Exemple 2 :>>

  56 <p Ce titre de chapitre s’écrit en HTML :>

  57 <code \<h1\>Chapitre III\</h1\>>

  58 <p Grâce aux métabalises, il peut devenir en PML :>

  59 <code \<chapitre III\>>

  60 <p Difficile de faire plus court et plus lisible, non ?>

  61 <espace_demi>

  62 <p « <i Mais que fait-on des classes et autres attributs ?> », me direz-vous…>

  63 <p Eh bien, le format général d’une balise PML (sauf balises contenant impérativement un lien, détaillés dans le chapitre <a ##cas_particuliers Cas particuliers>) est le suivant :>

  64 <code \<balise[.classe][#id][ #attr1=valeur][ #attr2=valeur] texte\>>

  65 <p Important : l’attribut ‘#id’ ne doit pas être précédé d’un espace, il doit être collé à la classe (ou au nom de la balise).>

  66 <p Ce qui correspond, en HTML, à :>

  67 <code \<balise[ class="classe"][ id="id"][ attr1=valeur][ attr2=valeur]\>texte\</balise\>>

  68 <espace_demi>

  69 <p Toutefois, sachant que HTML évolue vers le déplacement de tous les attributs (ou presque) vers les feuilles de style CSS, au point que beaucoup ont déjà été dépréciés en HTML4 et sont devenus invalides en HTML5, PML va dans le même sens et il est évidemment recommandé de faire le maximum en CSS.>

  70 <p S’il est toujours possible de déporter des attributs dans les métabalises, car cela simplifie tout autant le code PML, il faut savoir qu’en pareil cas ils sont répétés dans le HTML final autant de fois qu’est utilisée la métabalise. Néanmoins cela peut être utile en cas d’attributs susceptibles d’être souvent modifiés ou avec des métabalises ayant peu d’occurrences.>

  71 <espace_demi>

  72 <p « <i Même celles qui ne servent qu’une fois ?> »>

  73 <p Et pourquoi pas ? C’est d’ailleurs ce qui se passe depuis longtemps dans les documents aux formats .odt ou .docx – sauf que, évidemment, l’utilisateur ne le voit pas.>

  74 <espace_demi>

  75 <encadré

  76 ———›<p <b Note importante :>>

  77 ———›<p PML simplifie l’écriture de code HTML, mais ne s’occupe que de la syntaxe et non de la grammaire. S’il veille tout de même à vérifier l’existence des classes utilisées, il ne bronchera pas sur un <arial \<td texte\>> non inclus dans un <arial \<tr\>> ou carrément hors d’une table. Il restera tout aussi indifférent à un attribut numérique alimenté avec du texte ou vice-versa.>

  78 ———›<p Il construit un document HTML bétonné question syntaxe, mais le reste est le problème du navigateur qui l’interprétera pour l’afficher… et surtout de la personne qui code les pages !>

  79 ———›>

  80

  81 <chapitre 2. Un langage plus simple mais plus strict>

  82 #====================================================

  83

  84 <sous_chapitre 2.1. Notes aux utilisateurs Windows>

  85 #--------------------------------------------------

  86 <p 1. Pour utiliser PML, il est impératif que les fichiers soient en Unicode (UTF-8) et non en ISO-8859 ou (pire) en CP1252. (Sous Linux et sur Mac, Unicode est le codage standard par défaut.)>

  87 <p 2. Les programmes de conversion de/vers HTML étant en Python3, il est nécessaire d’installer Python pour pouvoir les utiliser. (Python est installé par défaut sous Linux et Mac. Il peut toutefois être nécessaire d’installer une version 3 si celle en place est antérieure.)>

  88

  89 <sous_chapitre 2.2. Caractères spéciaux>

  90 #---------------------------------------

  91 <p En PML, grâce à Unicode, il n’est nul besoin d’utiliser les codes en <arial &xxx;>, tous les caractères peuvent être entrés nativement. Néanmoins, les codes <arial &xxx;> ne sont pas refusés, ceux présents seront juste convertis (sauf s’ils correspondent aux délimiteurs de base HTML « \< », « \> » ou « & »).>

  92 <p Nota : contrairement à la tolérance de HTML5, les caractères spéciaux non délimités à droite par un ’;’ ne sont pas reconnus comme tels : ‘<arial &quota>’ ne générera pas ‘<arial "a>’, mais restera ‘<arial &quota>’.>

  93 <p Il n’existe que peu de caractères spéciaux interprétés par PML. L’important est de savoir que tout caractère susceptible d’être vu comme marqueur ou délimiteur alors qu’il s’agit de texte doit être « échappé », c’est-à-dire précédé du caractère « \\ ».>

  94 <p Ainsi, « \\\< » ne sera pas un début de balise, mais simplement le caractère « plus grand ». Bien sûr, si on veut insérer un « \\ » dans le texte, il faudra le doubler, sinon il sera traité comme échappement de celui qui le suit.>

  95 <p À noter qu’un caractère échappé inutilement ne prête pas à conséquence, il reste simplement lui-même. Et comme on a affaire à du texte pur (ce sont les balises qui font la mise en forme), « \\t » donnera un « t » et non une tabulation, « \\n » sera un « n » et non une fin de ligne, etc.>

  96

  97 <sous_chapitre 2.3. Règle de base>

  98 #---------------------------------

  99 <p La règle de départ PML est qu’une balise doit être contenue en entier sur une seule ligne. De cette manière, le contrôle syntaxique détecte immédiatement s’il y a le bon nombre de délimiteurs « \< » et « \> ».>

 100 <espace_demi>

 101 <p « Que se passe-t-il si les délimiteurs ne sont pas équilibrés ? »>

 102 <p Cela dépend dans quel sens :>

 103 <p S’il manque des fermetures, le programme de conversion émet un avertissement et ajoute les fermetures manquantes, de sorte que le code HTML obtenu est syntaxiquement propre – même si les fermetures ne sont pas nécessairement là où elles auraient dû.>

 104 <p S’il y a trop de fermetures, les « \> » excédentaires sont traités comme des caractères ordinaires et seront convertis en « > » dans le code HTML résultant. Là aussi, évidemment, il y a émission d’un avertissement.>

 105 <espace_demi>

 106 <p Globalement, le premier caractère d’une ligne non vide ou contenant autre chose que des espaces (ces lignes-là sont autorisées, mais ignorées) peut être :>

 107 <p <arial \<> : début de balise ;>

 108 <p <arial> : (tabulation), continuation de balise ;>

 109 <p <arial \#> : commentaire (cf. plus loin) ;>

 110 <p <arial §> : définition de métabalise (cf. plus loin).>

 111 <p Tout autre caractère est une erreur.>

 112

 113 <sous_chapitre 2.4. Balises longues>

 114 #-----------------------------------

 115 <p Naturellement, il est fréquent qu’une balise HTML encadre un peu trop d’informations pour tenir confortablement sur une seule ligne, ou que (notamment pour les tableaux) la lisibilité impose un découpage en plusieurs lignes.>

 116 <p C’est évidemment possible tout en respectant le principe précédent, et ce très simplement en faisant appel à la même règle que celle qui gère les blocs en langage Python : l’indentation.>

 117 <espace>

 118 <p Par exemple, le tableau de la page 2 peut s’écrire en HTML :>

 119 <code \<table\><br>→\<tr\><br>→→\<td\>A1\</td\><br>→→\<td\>B1\</td\><br>→\</tr\><br>→\<tr\><br>→→\<td\>A2\</td\><br>→→\<td\>B2\</td\><br>→\</tr\><br>\</table\>>

 120 <p Évidemment, les indentations (ou les espaces) ne servent ici qu’à la lisibilité et ne jouent aucun rôle par ailleurs : le tableau s’affichera exactement de la même façon si on écrit ceci :>

 121 <code \<table\><br>\<tr\><br>\<td\>A1\</td\><br>\<td\>B1\</td\><br>\</tr\><br>\<tr\><br>\<td\>A2\</td\><br>\<td\>B2\</td\><br>\</tr\><br>\</table\>>

 122 <espace>

 123 <p En PML, le caractère d’indentation joue un rôle fondamental. Sa présence au début d’une ligne signale au convertisseur que la ligne précédente n’est pas complète et qu’il s’en faut d’autant de fermetures qu’il y a de tabulations.>

 124 <p On peut donc écrire la table ainsi :>

 125 <code \<table<br>→\<tr<br>→→\<td A1\><br>→→\<td B1\>\><br>→\<tr<br>→→\<td A2\><br>→→\<td B2\>\>\>>

 126 <p S’il manque des fermetures, il y aura avertissement(s), mais le code HTML généré sera néanmoins correct.>

 127 <p En revanche, si on code :>

 128 <code \<table<br>\<tr<br>\<td A1\><br>\<td B1\>\><br>\<tr<br>\<td A2\><br>\<td B2\>\>\>>

 129 <p le résultat HTML sera celui-ci :>

 130 <code \<table /\><br>\<tr /\><br>\<td\>A1\</td\><br>\<td\>B1\</td\>><br>\<tr /\><br>\<td\>A2\</td\><br>\<td\>B2\</td\>>>>

 131 <p.just0 avec pas moins de 5 avertissements !>

 132 <espace>

 133 <p Attention : si on veut carrément séparer les délimiteurs fermants, il faut écrire :>

 134 <code →\<tr<br>→→\<td A1\><br>→→\<td B1\><br>→→\>>

 135 <p.just0 et non>

 136 <code →\<tr<br>→→\<td A1\><br>→→\<td B1\><br>→\>>

 137 <p.just0 qui donnerait>

 138 <code →\<tr\><br>→→\<td\>A1\</td\><br>→→\<td\>B1\</td\>\</tr\><br>→>>

 139 <p.just0 avec un avertissement. En effet, le délimiteur fermant fait partie de la « ligne » commençant par « \<tr » et doit donc être indenté par rapport à ce début pour être considéré comme en faisant partie.>

 140 <espace_demi>

 141 <p Arrivé ici, je vous entends déjà penser : « <i Et si on met plus de tabulations que nécessaire ?> »>

 142 <p Eh bien, dans ce sens-là, pas de problème : les tabulations excédentaires sont purement et simplement ignorées.>

 143 <espace_demi>

 144 <p Pour info, le code HTML généré conserve les tabulations utiles, préservant donc la lisibilité.>

 145 <espace>

 146 <p <b Important :> si on veut un retour à la ligne (pour lisibilité) sans que celui-ci soit assimilable à un espace syntaxique (ex. dans un attribut « style » un peu long), il faut terminer la ligne par un ‘\\’ accolé au dernier caractère. Ex. :>

 147 <code \< div #style=position:absolute;left:200px;top:100px;display:table;<br>

 148 ———›→width:100px;height:100px;margin:auto;text-align:center texte-du-div\>>

 149 <p.just0 générera le code html erroné (bien que syntaxiquement valide) :>

 150 <code \<div style="position:absolute;left:200px;top:100px;display:table;"\><br>

 151 ———›→width:100px;height:100px;margin:auto;text-align:center texte…\</div\>>

 152 <p.just0 tandis que :>

 153 <code \<div #style=position:absolute;left:200px;top:100px;display:table;\\<br>

 154 ———›→width:100px;height:100px;margin:auto;text-align:center texte-du-div\>>

 155 <p.just0 générera correctement :>

 156 <code \<div style="position:absolute;left:200px;top:100px;display:table;<br>

 157 ———›→width:100px;height:100px;margin:auto;text-align:center"\>texte…\</div\>>

 158 <p Pour info, c’est le même principe que dans le langage Python.>

 159

 160 <sous_chapitre 2.5. Texte pur>

 161 #-----------------------------

 162 <p Il peut arriver que certaines parties ne doivent surtout pas être décodées ni altérées (ex. du javascript pouvant contenir des caractères spéciaux PML qui ne sont pas à prendre en compte comme tels). Il suffit alors de les placer entre triples « apostrophes ». Ex :>

 163 <code (\<script \'''…\'''\>)>

 164 <p <u Remarque :> Cela peut également être utile pour définir des attributs dont la chaîne contient des espaces, il est ainsi inutile des les échapper.>

 165 <espace_demi>

 166 <encadré

 167 ———›<p <u <b Attention :>> Si dans ce texte pur il y a des paramètres (<arial \<*…\>>), constantes (<arial \<%…\>>) ou littéraux (<arial \<@…\>>) qui doivent être résolus, il suffit de les « sortir » du mode texte pur en les encadrant par des triples « apostrophes ».>

 168 ———›<p Exemples (javascript) :>

 169 ———›<code ———›\'''doc.balise.balisecode.value = "\<%titre\>";\'''>

 170 ———›<p.juste0 enverra la valeur <arial \<%titre\>> telle quelle. Tandis que :>

 171 ———›<code ———›\'''doc.balise.balisecode.value = "\'''\<%titre\>\'''";\'''>

 172 ———›<p.juste0 enverra correctement la valeur de la constante.>

 173 ———›>

 174

 175 <sous_chapitre 2.6. Commentaires>

 176 #--------------------------------

 177 <p Il est évidemment possible d’incorporer des commentaires pour une meilleure compréhension du texte.>

 178 <p Il suffit que la ligne commence par un « # » :>

 179 <code \#commentaire>

 180 <p Mais par défaut ce commentaire ne sera pas repris dans le code HTML généré (notamment afin d’alléger celui-ci au maximum).>

 181 <p Si on veut qu’il soit répercuté, il faut alors doubler le caractère initial :>

 182 <code \##commentaire>

 183 <p apparaîtra dans le HTML généré comme :>

 184 <code \<!-- commentaire --\>>

 185 <espace>

 186 <p On peut aussi mettre des commentaires dans le corps d’une balise :>

 187 <code \<balise … \<#commentaire\> …\>>

 188 <p De même, le commentaire ne sera maintenu que s’il commence avec un double « # ».>

 189 <espace>

 190 <p <b Note :> le commentaire commence immédiatement après le <arial \#> ou <arial \##>, il peut donc indifféremment y avoir ou non un espace de séparation.>

 191 <p Un commentaire peut s’étendre sur plusieurs lignes, à condition de respecter l’indentation par tabulation. En outre, s’il contient des balises, celles-ci seront identifiées mais ignorées. De sorte qu’il suffit de mettre un « # » comme premier caractère d’une balise pour que celle-ci soit entièrement ignorée avec tout ce qu’elle contient.>

 192 <p Si une séquence « -- » figure dans un commentaire (ce qui est interdit en HTML puisque délimiteur de commentaire), elle sera remplacée dans un commentaire à répercuter par un tiret semi-cadratin «  ».>

 193

 194 <sous_chapitre 2.7. Spécificités diverses et précisions>

 195 #-------------------------------------------------------

 196 <p Afin que le code HTML généré soit optimisé, il y a deux traitements différents pour les balises vides :>

 197 <p.liste 1. Les balises ne servant qu’à mettre le texte en forme sont ignorées en l’absence dudit texte (c’est-à-dire ne contenant ni lettres ni chiffres), avec émission d’un message d’avertissement. C’est le cas de <arial \<i\>>, <arial \<b\>>, <arial \<s\>>, <arial \<em>\>, <arial \<strong\>>, etc. et en général de tout ce qui est définissable par <arial \<span …\>>. Si nécessaire, accoler un ‘+’ de forçage à la balise afin qu’elle soit prise en compte (ex. <arial \<sup+ ,\ \>> pour mettre une virgule entre deux appels de note consécutifs).>

 198 <p.liste 2. Les balises jouant un rôle dans la mise en page sont préservées : un paragraphe vide ne disparaîtra pas.>

 199 <p.liste 3. Il y a également vérification des <arial id> : seuls les identifiants référencés ailleurs dans le document (liens) sont conservés dans le code HTML générés. En outre, les <arial id> référencés mais non définis donnent lieu à avertissement (et sont également supprimés).>

 200 <p.liste 4. Les balises de plus haut niveau <arial \<html\>>, <arial \<head\>> et <arial \<body\>> étant générées systématiquement, elles ne sont pas acceptées dans un document PML.>

 201

 202 <chapitre 3. Les métabalises>

 203 #============================

 204

 205 <sous_chapitre 3.1. Principe>

 206 #----------------------------

 207 <p Les métabalises complètent et enrichissent le principe des feuilles de style. Dans un document PML, on peut les définir, comme les styles CSS, de deux façons différentes :>

 208 <espace_demi>

 209 <p 1. Dans un ou plusieurs fichiers de métabalises qu’on spécifie dans la première ligne du document, laquelle se présente comme ceci :>

 210 <code \<pml[ balises.pss[ balises2.pss[…]]]\>>

 211 <p (les noms des fichiers peuvent être quelconques et même contenir un chemin, il faut juste qu’ils soient suffixés par « .pss »)>

 212 <espace_demi>

 213 <p 2. Directement dans le document, à la suite de la première ligne ci-dessus :>

 214 <code \<pml\><br>

 215 ———›§balise \<code…\><br>

 216 ———›>

 217 <espace_demi>

 218 <p Les deux méthodes sont cumulables, sachant qu’en cas d’identité de métabalise, celle définie en dernier (ordre des fichiers puis directement dans le document) est prioritaire.>

 219 <p En outre, s’il existe un fichier ‘pmlexport.pss’ dans le répertoire du programme ‘pmlexport.py’, il est pris en compte en tout premier. C’est un moyen de définir des métabalises généralisées.>

 220 <p Attention : contrairement aux autres balises, l’ensemble de \<pml…\> doit figurer sur une seule ligne (pas de retour même avec une tabulation) !>

 221 <espace>

 222 <p Qu’elle soit dans un fichier séparé ou directement dans le document, une métabalise se présente comme suit :>

 223 <code §balise \<code équivalent\>>

 224 <p Si sa définition est longue, elle peut être répartie sur plusieurs lignes, les suivantes étant obligatoirement indentées d’un cran (la tabulation compte comme un espace – si le retour ligne n’achève pas l’élément par l’équivalent d’un espace, il faut échapper ce retour par un ‘\\’ en fin de ligne, ce qui sera interprété par un espace non délimiteur).>

 225 <espace_demi>

 226 <p <u Exemple :>>

 227 <p Si on a des styles CSS du genre :>

 228 <code span.rouge {color:red}<br>span.bleu {color:blue}<br>span.vert {color:red}>

 229 <p on peut définir une balise spécifique à chaque couleur :>

 230 <code §rouge \<span class="rouge"\>>

 231 <p Et mettre un bout de texte en rouge en devient d’une simplicité presque déconcertante :>

 232 <code \<rouge texte\>>

 233 <p On peut même aller plus loin :>

 234 <code §rougegras \<rouge style="text-weight:bold"\>>

 235 <p Ou encore, si on a défini une classe .gras {text-weight:bold}, on peut écrire :>

 236 <code \<rouge.gras texte\>>

 237 <p qui correspondra en HTML à :>

 238 <code \<span class="rouge gras"\>texte\</span\>>

 239 <p Eh oui, les métabalises sont elles-mêmes redéfinissables.>

 240 <espace>

 241 <p On pourrait aussi définir la balise « rouge » sans passer par CSS en la définissant comme ceci :>

 242 <code §rouge \<span style="color:red"\>>

 243 <p … mais dans ce cas le code HTML généré sera :>

 244 <code \<span style"color:red"\>texte\</span\>>

 245 <p Donc valable pour des styles et attributs à usage unique ou presque, mais déconseillé là où les classes ont leur utilité. Éviter donc de définir une métabalise pour une balise contenant des attributs non paramétrés (sauf, éventuellement et temporairement, pour faciliter la mise au point), une définition en feuille de style est largement préférable.>

 246 <espace>

 247 <p Pour aller encore plus loin, une métabalise peut même contenir du texte prédéfini.>

 248 <espace>

 249 <p Exemple du chapitre donné en page 2 :>

 250 <code §chapitre \<h1 Chapitre\>>

 251 <p Le texte associé à la balise dans le code normal PML se place par défaut après celui incorporé dans la définition, séparé par une espace. Il est cependant possible de le positionner avant ou dedans, en spécifiant \<*\> dans cet attribut.>

 252 <espace_demi>

 253 <p <u Exemple :> avec les métabalises>

 254 <code §partie \<h1 class="partie" \<*\> partie\><br>§re \<sup re\>>

 255 <p.just0 le bref texte>

 256 <code \<partie 1\<re\>\>>

 257 <p.just0 sera converti comme>

 258 <code \<h1 class="partie"\>1\<sup\>re\</sup\> partie\</h1\>>

 259 <espace>

 260 <p <u Important :> tous les attributs d’une balise HTML peuvent être utilisés tels quels dans la définition d’une balise. Mais le premier élément qui ne serait pas de la forme <arial xxxx="yyy"> sera identifié comme début du texte ordinaire.>

 261 <espace_demi>

 262 <p <b Note :> certaines balises particulières (comme <arial img> ou <arial a> explicitées plus loin) peuvent avoir un (et un seul) attribut obligatoire qui alors peut être entré sans mot-clé (ex. #<arial image.jpg>), mais doit obligatoirement venir en première position (voir plus bas).>

 263 <espace_demi>

 264 <p <u Remarque :> comme vous l’avez constaté, le nom d’une balise peut contenir des caractères accentués. Mais seuls sont autorisés chiffres, lettres et le « souligné » (« _ »), le premier caractère ne pouvant être un chiffre.>

 265 <p Par défaut, le texte ajouté lors de l’usage d’une métabalise sera séparé du texte pouvant y figurer par une espace. S’il doit au contraire être accolé, l’emplacement du texte doit être explicité avec un ‘<arial \<*\>>’.>

 266 <p Attention :>

 267 <p.liste a. Si une espace, insécable ou ordinaire, est déjà présente en fin de texte dans la métabalise, aucune espace supplémentaire n’est ajoutée.>

 268 <p.liste b. Si aucun texte n’est à ajouter, seules les espaces explicitement mises dans la métabalise sont conservées.>

 269 <espace>

 270 <p Enfin, la combinaison de classes reste possible :>

 271 <code \<balise.a+b#c texte\>>

 272 <p.just0 générera>

 273 <code \<balise class="a b" id="c"\>texte\</balise\>>

 274 <p Le signe « + » remplace l’espace uniquement dans ce cas. Il n’a aucun autre usage particulier en PML, à l’exception de forcer la validation d’une balise qui serait autrement ignorée car identifiée comme inutile (« <arial \<i ,\>> » deviendra « , », mais « <arial \<i+ ,\>> » deviendra « <arial \<i\>,\</i\>> »).>

 275

 276 <sous_chapitre 3.2. Les paramètres>

 277 #----------------------------------

 278 <p On peut bien sûr se passer de style CSS en utilisant le mode paramètre (valeurs précédées d’un #) :>

 279 <code §c \<span style="color:\<*1\>"\>>

 280 <p.just0 et définir n’importe quelle couleur ainsi :>

 281 <code \<c #red texte\>>

 282 <p.just0 ou>

 283 <code \<c ##ff0000 texte\>>

 284 <p Évidement, en l’absence de style CSS, la spécification de couleur est répétée dans le document HTML avec le code généré :>

 285 <code \<span style="color:#ff0000"\>texte\</span\>>

 286 <p Vous remarquerez qu’on a séparé le nom de la métabalise de la valeur non par un point mais par un espace. C’est ce qui permet à PML de savoir qu’on n’a plus affaire à une classe ou un identifiant, mais à un ou plusieurs paramètres.>

 287 <p Par exemple, si on a besoin de définir différents blocs <arial div> identiques sauf leur position, celle de chacun étant unique, on peut utiliser la définition suivante :>

 288 <code §pavé \<div #style=position:absolute;left:\<*1\>px;top:\<*2\>px;display:table;\\<br>→→width:100px;height:100px;margin:auto;text-align:center\>>

 289 <p (Vous noterez la présence d’un échappement et de deux indentations : en effet, ‘\\’ indique qu’on reste dans ‘style’ et pour les indentations, il en faut une pour indiquer qu’on poursuit la définition de « pavé » et une autre pour indiquer qu’on est toujours dans « div ».)>

 290 <p Chaque bloc pourra alors être défini dans le corps du document comme suit :>

 291 <code \<pavé #100 #200 texte\>>

 292 <p Autre méthode, plus conviviale :>

 293 <code §pavé \<div #style=position:absolute;left:\<*x\>px;top:\<*y\>px;display:table;<br>→→width:100px;height:100px;margin:auto;text-align:center\>>

 294 <p.just0 permet d’écrire :>

 295 <code \<pavé #x=100 #y=200 texte\>>

 296 <espace>

 297 <p La première manière (<arial \<*1\>>, <arial \<*2\>>) donne les paramètres dans l’ordre où ils doivent être fournis, tous étant impératifs (il est toutefois possible de passer un paramètre « nul » en mettant un « # » isolé au bon emplacement dans la liste. Attention : la valeur <arial \<*0\>> ne doit pas être utilisée, elle est « réservée » et ne concerne que les définitions implicites.>

 298 <p La deuxième manière (<arial \<*x\>>, <arial \<*y\>> associe des noms aux paramètres, ce qui permet de les donner dans un ordre quelconque… et surtout de voir immédiatement leur signification. L’astérisque devant le nom indique qu’on a affaire à un paramètre et non à une (méta)balise.>

 299 <p Plus encore, il est possible de donner une valeur par défaut à chaque paramètre :>

 300 <code §pavé \<div style=position:absolute;left:\<*x=0\>px;top:\<*y=0\>px;display:table;<br>→→width:100px;height:100px;margin:auto;text-align:center\>>

 301 <p permet d’écrire :>

 302 <code \<pavé #y=200 texte\>>

 303 <p.just0 qui aura donc les coordonnées <arial x=0> (valeur par défaut) et <arial y=200>, un paramètre ayant une valeur par défaut devenant facultatif.>

 304 <espace>

 305 <encadré

 306 ———›<p Attention : une valeur de paramètre étant une chaîne de caractères susceptible de contenir n’importe quoi, il faut veiller à échapper tout caractère « ambigu » tel qu’un espace.>

 307 ———›>

 308 <p En résumé, une « balise » commençant par « * » dans une définition de métabalise définit un paramètre ; un « mot » commençant par « # » dans une balise est une valeur de paramètre.>

 309 <p PML considère la liste des paramètres terminée au premier mot ne commençant pas par « # ». Si par hasard le premier mot non paramètre doit commencer par ce caractère, il suffit de l’échapper (« \\# »), faute de quoi il sera soit pris comme paramètre suivant (si la liste était incomplète), soit ignoré (paramètre en trop).>

 310 <espace>

 311 <p Les paramètres positionnels et par mots-clés sont cumulables, mais les premiers doivent tous être précisés AVANT les seconds.>

 312 <espace>

 313 <p Si des paramètres positionnels en trop sont fournis, ils sont juste ignorés, avec émission d’un message d’avertissement.>

 314 <p Si des paramètres nommés mais non définis sont fournis, ils sont traités comme des attributs HTML :>

 315 <code \<balise #size=100 texte\>>

 316 <p.just0 donnera>

 317 <code \<balise size="100"\>texte\</balise\>>

 318 <espace>

 319 <p Le paramètre simplement défini par \<*\> est exclusivement réservé au texte associé à la (méta)balise. On peut d’ailleurs considérer qu’il y a « \<*\> » implicite en fin de définition quand il n’est pas explicite à un autre emplacement.>

 320 <espace>

 321 <encadré

 322 ———›<p <u Rappel :> les exemples « div » ci-dessus ne sont naturellement pas recommandés tels quels car générant des « div » à rallonge. Les classes « css » sont là pour stocker les attributs de valeurs communes.>

 323 ———›>

 324 <espace>

 325 <p Enfin, il est possible de conditionner le « conteneur » d’un paramètre à l’existence de celui-ci (sachant qu’un paramètre avec valeur existera toujours), il suffit de placer la partie conditionnelle dans une balise avec « <arial **> ».>

 326 <p Si aucun paramètre ne figure dans une balise conditionnelle, celle-ci est systématiquement traitée comme si elle avait un paramètre renseigné.>

 327 <espace_demi>

 328 <p <u Attention :> si une balise conditionnelle contient plusieurs paramètres, il suffit qu’un seul ne soit pas renseigné pour que l’ensemble soit éliminé.>

 329 <espace_demi>

 330 <p Exemple :>

 331 <code §image \<img #style=\<** width:\<*l\>;\>\<** height:\<*h\>;\>\>>

 332 <p Si on écrit ceci :>

 333 <code \<image #xxxxx.jpg #h=100px\>>

 334 <p.just0 le code HTML sera le suivant :>

 335 <code \<img src="xxxxx.jpg" style="height:100px;" /\>>

 336 <p (Si aucun paramètre n’est spécifié, PML détectera le « style » vide et l’éliminera complètement.)>

 337

 338 <sous_chapitre 3.3. Les balises « maison » et blocs>

 339 #---------------------------------------------------

 340 <p Pour améliorer et « bétonner » certains documents, il est possible de définir des métabalises ne correspondant à aucun balisage HTML. La pseudobalise à utiliser est un « § » seul.>

 341 <p Par exemple :>

 342 <code §question \<p — \<*\> ?\><br>§guil \<§ « \<*\> »\>>

 343 <p.just0 remplaceront :>

 344 <code \<question Vous avez dit \<guil Bizarre\>\>>

 345 <p.just0 par :>

 346 <code \<p\>— Vous avez dit « Bizarre » ?\</p\>>

 347 <p L’intérêt ? Eh bien, si vous devez pour une raison ou une autre changer le mode de mise entre guillemets dans tout un document (par exemple des guillemets anglais), il suffit de modifier la définition de la métabalise :>

 348 <code §guil \<§ “\<*\>”\>\>>

 349 <p.just0 et le tour est joué !>

 350 <p Certes, il est en principe possible d’en faire autant avec du css et les pseudo-classes ‘:before’ et ‘:after’, mais ça implique du \<span …\> à tout va dans le code html, et donc un traitement plus lourd par le navigateur. Tandis qu’avec PML, on a une forme de précompilation qui fournit le résultat « en dur » au navigateur.>

 351 <espace>

 352 <p L’autre force est de permettre de créer des blocs complets, avec ou sans paramètres, qui pourront être intégrés à la page (ou à l’ePub) de la manière la plus simple qui soit.>

 353 <espace_demi>

 354 <p <u Exemple :>>

 355 <code §identifiant \<§ \<h1 <insécable>\><br>

 356 ———›→→\<div #style=align:center<br>

 357 ———›→→→\<p.centre ISBN \<*1\>\><br>

 358 ———›→→→\<p.centre © \<*2\> Éditions maison\><br>

 359 ———›→→→\>\>>

 360 <p En mettant simplement dans le fichier source :>

 361 <code \<identifiant #978-2-7544-2017-6 #2017\>>

 362 <p.just0 on obtient une page spéciale :>

 363 <code \<h1\><insécable>\</h1\><br>

 364 ———›\<div style="align:center"\><br>

 365 ———›→\<p class="centre"\>ISBN 978-2-7544-2017-6\</p\><br>

 366 ———›→\<p class="centre"\>© 2017 Éditions maison\>\</p\><br>

 367 ———›→\</div\>>

 368 <p (La marque « <insécable> » matérialise une espace insécable.)>

 369 <p Cette méthode est très pratique pour définir des entêtes, pieds de page, pages de garde, etc. communs à diverses pages ou documents.>

 370 <p Il est toutefois fortement conseillé de mettre ce genre de définition dans un fichier .pss et non directement dans le fichier source .pml (ce qui aurait évidemment beaucoup moins d’intérêt…) Une autre solution, plus élégante, consiste à définir ce code dans un fichier importé et de faire appel à des constantes plutôt qu’à des paramètres (voir chapitre suivant).>

 371

 372 <chapitre#cas_particuliers 4. Cas particuliers et spécificités>

 373 #==============================================================

 374

 375 <p Si le format général d’une balise PML est le suivant :>

 376 <code \<balise[.classe][#id][ #paramètres…][ attributs=…] texte\>>

 377 <p.just0 il existe comme déjà dit quelques cas particuliers, détaillés ci-après.>

 378

 379 <sous_chapitre 4.1. Images et liens hypertexte, balises avec 'value'>

 380 #--------------------------------------------------------------------

 381 <p Pour une image (balise <arial \<img …\>>), le format est :>

 382 <code \<img[.classe][#id] #lien [ #attributs=…] [texte]\>>

 383 <p Si le lien est évidemment obligatoire (attribut implicite <arialb src>), le texte, en revanche, est facultatif (et même, de nos jours, pratiquement superflu). Si un texte est fourni, il sera seulement utilisé comme valeur d’attribut « alt » (et concaténé à celle-ci si également fournie explicitement).>

 384 <espace_demi>

 385 <p Pour un lien hypertexte (balise <arial \<a …\>>), même format :>

 386 <code \<a[.classe][#id] #lien [ #attributs=…] [texte]\>>

 387 <p Le lien est bien sûr obligatoire (attribut implicite <arialb href>). Le texte, lui, si utile, est facultatif. S’il est absent, c’est le lien lui-même qui sera utilisé en ses lieu et place.>

 388 <espace_demi>

 389 <p Vous noterez que tant pour <arialb a> que pour <arialb img> le format est bien standard PML. La spécificité vient juste de ce que ces balises sont définies implicitement comme suit :>

 390 <code §a href="\<*0\>" \<*=#0\>\><br>§img src="\<*0\>" [alt="\<*\>"]\>>

 391 <p De ce fait, quelles que soient les redéfinitions éventuelles, le lien doit toujours être le premier paramètre fourni (et le texte évidemment toujours à la fin).>

 392 <espace_demi>

 393 <p Note : on peut considérer que le lien de ces balises équivaut au paramètre \<*0\> implicite. Il doit donc impérativement être le premier paramètre fourni.>

 394 <espace_demi>

 395 <encadré

 396 ———›<p <u <b Attention :>> si des liens image ou hypertexte sont définis dans des métabalises, les mots-clés « <arial href> » ou « <arial src> » doivent être explicitement mis, faute de quoi il peut y avoir collision avec les paramètres de la métabalise.>

 397 ———›<p De même, il se peut que ne puisse être utilisé le paramètre par défaut <arial \<*\>> et qu’il faille utiliser un paramètre genre <arial \<*1\>>, ou parfois même un paramètre nommé genre <arial \<*num\>>.>

 398 ———›>

 399 <espace_demi>

 400 <p Pour les balises <arialb input>, <arialb li>, <arialb option>, <arialb meter>, <arialb progress> et <arialb param>, qui n’accueillent normalement pas de texte mais seulement un attribut <arialb value>, celui-ci peut être omis et son contenu placé comme texte normal, il sera automatiquement attribué à cet attribut (ou concaténé à la valeur existante si <arial value> est également fourni explicitement). Ceci permet par exemple d’utiliser des constantes reçues en paramètres pour les mettre dans un champ de saisie, même si le texte contient des espaces.>

 401 <espace_demi>

 402 <p <u Exemple :>>

 403 <code \<input #type=text #name=c_objet #maxlength=64 #size=40 \<%c_objet\>\>>

 404 <p Si <arial %c_objet> contient le texte saisi « Problème technique », le code résultant sera :>

 405 <code \<input size="40" maxlength="64" name="c_objet" type="text" value="Problème technique" /\>>

 406 <p Alors que si on avait écrit :>

 407 <code \<input #type=text #name=c_objet #maxlength=64 #size=40 #value=\<%c_objet\>\>>

 408 <p.just0 ça aurait donné :>

 409 <code \<input size="40" maxlength="64" name="c_objet" type="text" value="Problème"\>technique\</input\>>

 410 <p.just0 qui est non seulement non attendu, mais également invalide en tant que code HTML (même si les navigateurs l’affichent).>

 411

 412 <sous_chapitre 4.2. SVG>

 413 #-----------------------

 414 <p Les images vectorielles SVG peuvent être incluses directement dans un document HTML5, ses balises étant spécifiques… Mais certaines ayant le même nom que des balises normales HTML, toutes les balises internes à un bloc \<svg\> doivent être préfixées par ‘svg@’ afin de préserver l’unicité globale.>

 415 <p Exemple :>

 416 <code →\<svg_1<br>

 417 ———›→→\<svg@image #width=422 #height=705 #xlink:href=cover.jpeg\><br>

 418 ———›→→\>>

 419

 420 <sous_chapitre 4.3. Petites capitales : \<smallcaps …\>>

 421 #-------------------------------------------------------

 422 <p L’attribut de style <arial small-caps> (<arial font-variant:small-caps>) étant très mal supporté par les logiciels de lecture (notamment tous ceux qui utilisent le moteur Adobe), une balise spéciale s’y substitue :>

 423 <code \<smallcaps texte\>>

 424 <p Lors de l’exportation, son contenu est remplacé par un ou plusieurs <arial \<span class="sc" …\>> (classe qu’il faut définir dans la feuille css utilisée, par exemple <arial .sc { font-size:75%;}>, faute de quoi la balise n’aura aucun effet). Seuls les caractères alphabétiques en minuscules sont convertis. Les caractères non concernés (capitales, chiffres, ponctuations, espaces, etc.) restent hors balise (d’où souvent plusieurs occurrences de celle-ci).>

 425 <p Note : lorsque l’attribut susmentionné sera enfin supporté, il sera très simple de modifier le traitement de cette balise, ne serait-ce qu’en la redéfinissant dans « pml.cfg ».>

 426

 427 <sous_chapitre 4.4. Notes : \<note …\>>

 428 #--------------------------------------

 429 <p Une balise spécifique est définie pour les notes de bas de page :>

 430 <code \<note texte\>>

 431 <p Il suffit de la positionner dans le corps du texte. Lors de la conversion HTML, un lien hypertexte numéroté est automatiquement généré, et le contenu de la note généré à la fois en boîte surgissante (pop-up) de type \<aside …\> pour les logiciels compatibles HTML5/css3 <rouge (à venir)>, et par défaut à la fin du bloc conteneur pour les affichages « classiques ».>

 432 <p Il est possible de personnaliser le fonctionnement des notes, et même d’en définir de plusieurs sortes.>

 433 <p La définition par défaut est celle-ci :>

 434 <code §note \<note #parent=h1 #format=[1] #début=1 #init=h1 #classeref=note<br>→#classetxt=txtnote\>>

 435 <p Ce qui se décode ainsi :>

 436 <p les notes sont regroupées à la fin de chaque niveau <arialb h1> (parent) ;>

 437 <p elles sont numérotées en chiffres arabes à partir de <arialb 1> et encadrées par des crochets (format) ;>

 438 <p la numérotation repart à <arialb 1> à chaque rupture ;>

 439 <p la numérotation recommence au début à chaque niveau <arialb h1> (init) ;>

 440 <p la classe CSS des renvois est <arialb note> ;>

 441 <p la classe CSS des notes proprement dites est <arialb txtnote>.>

 442 <p Si on veut des notes en chiffres romains minuscules entre parenthèses avec numérotation sur tout le document, il suffit de redéfinir ainsi :>

 443 <code §note \<note \<*format=(i)\> \<*init=body\>\>>

 444 <p Type et point de départ de la numérotation se définissent ainsi :>

 445 <p Le premier de ces 6 caractères [1,a,A,i,I,*] trouvé définit le mode de numérotation :>

 446 <p <arialb 1> générera <arialb 1>, <arialb 2>, <arialb 3>… (mode par défaut)>

 447 <p <arialb a> générera <arialb a>, <arialb b>, <arialb c><arialb z>, <arialb aa>, <arialb ab>, etc. (resp. <arialb A> pour <arialb A>, <arialb B>, <arialb C>…)>

 448 <p <arialb I> générera <arialb I>, <arialb II>, <arialb III>, <arialb IV>… (resp. <arialb i> pour <arialb i>, <arialb ii>, <arialb iii>, <arialb iv>…)>

 449 <p <arialb *> générera <arialb *>, <arialb **>, <arialb ***>, <arialb ****>… (déconseillé au-delà d’une demi-douzaine de notes).>

 450 <p S’il y a plusieurs caractères, ceux qui précèdent et suivent celui défini plus haut sont utilisés comme préfixe et suffixe.>

 451 <p Si aucun des 6 caractères de format n’est trouvé, le format par défaut sera utilisé.>

 452 <p Pour <arial parent> et <arial init>, veiller à ce que <arial parent> soit d’un niveau égal ou supérieur à <arial init>, faute de quoi on risquerait de trouver plusieurs notes de même numéro en fin de bloc parent.>

 453 <p Si <arial début> n’est pas numérique ou est inférieur à 1, sa valeur sera forcée à 1.>

 454 <p Pour modifier les paramètres de <arialb note>, il suffit de redéfinir cette métabalise en reprenant uniquement les paramètres concernés.>

 455 <p Il est possible de faire coexister plusieurs notations indépendantes. Pour ce faire, il suffit de définir des métabalises dont le nom commence par note (ex. note1, notefin, etc.). Ex. :>

 456 <code §notefin \<note #parent=body #format=[i] #init=body #classeref=note<br>→#classetxt=txtnotefin\>>

 457 <p permet d’insérer des notes de fin de volume numérotées en romain et ayant un style différent de celles de bas de page.>

 458 <p Nota : Toutefois, un seul type de note par balise parent est possible. Même s’il y a plusieurs définitions avec des noms différents, chacune ne fera que redéfinir la précédente.>

 459

 460 <sous_chapitre 4.5. Note(s) répétée(s) : \<notebis\>>

 461 #----------------------------------------------------

 462 <p Permet de n’avoir qu’une seule note réelle pour plusieurs éléments référencés.>

 463 <espace_demi>

 464 <p <u Exemple :>>

 465 <code \<p Il montrait plusieurs \<i makiwara\>\<note Accessoires de karaté pour s’entraîner aux \<i atémis\> ou coups frappés.\> arrachés aux murs, un \<i sunatawara\>\<notebis\> suspendu dans un coin. Un peu partout, il y avait des \<i take-maki\>\<notebis\> appuyés à la muraille.\>>

 466 <p.just0 générera dans le texte :>

 467 <code \<p\>Il montrait plusieurs \<i\>makiwara\</i\>\<span class="note"\>\<a href="#note_20" id="noteref_20"\>[8]\</a\>\</span\> arrachés aux murs, un \<i\>sunatawara\</i\>\<span class="note"\>\<a href="#note_21" id="noteref_21"\>[9]\</a\>\</span\> suspendu dans un coin. Un peu partout, il y avait des \<i\>take-maki\</i\>\<span class="note"\>\<a href="#note_22" id="noteref_22"\>[10]\</a\>\</span\> appuyés à la muraille.\</p\>>

 468 <p.just0 et en fin de chapitre (ou de l’emplacement défini en paramètre si différent) :>

 469 <code \<p class="txtnote"\>\<a href="#noteref_20" id="note_20"\>[8]\</a\>,\<a href="#noteref_21" id="note_21"\>[9]\</a\>,\<a href="#noteref_22" id="note_22"\>[10]\</a\> Accessoires de karaté pour s’entraîner aux \<i\>atémis\</i\> ou coups frappés.\</p\>>

 470 <p.just0 soit à l’affichage :>

 471 <code Il montrait plusieurs <i makiwara><sup <bleu [8]>> arrachés aux murs, un <i sunatawara><sup <bleu [9]>> suspendu dans un coin. Un peu partout, il y avait des <i take-maki><sup <bleu [10]>> appuyés à la muraille.>

 472 <p et>

 473 <code <bleu [8]>,<bleu [9]>,<bleu [10]> Accessoires de karaté pour s’entraîner aux <i atémis> ou coups frappés.>

 474 <espace_demi>

 475 <p <u Note :> Ceci ne fonctionne bien sûr que pour des entrées consécutives.>

 476

 477 <sous_chapitre 4.6. Sommaire : \<toc\>>

 478 #--------------------------------------

 479 <p Il est possible de faire générer un sommaire pour le document. Pour ce faire, il suffit de définir une métabalise ‘toc’ décrivant ce sommaire :>

 480 <code §toc \<h1[.sommaire] #1=chapitre,titre,classe #prefixe=toc_ Sommaire\>>

 481 <p.just0 et de placer une balise <arial \<toc\>> à l’emplacement désiré dans le document.>

 482 <p.liste <arialb h1> : balise html de titre du sommaire. La valeur ‘h1’ est requise.>

 483 <p.liste <arial .sommaire> : le style css du titre du sommaire (par défaut, le style normal de <arial h1>).>

 484 <p.liste <arialb \#n> : niveau d’indentation des entrées du sommaire. Pour un sommaire simple, le 1 suffit. Pour un sommaire plus élaboré (ex. parties et chapitres), on peut définir en sus un niveau 2, etc. Si aucun niveau n’est défini, ‘#1=h1’ est utilisé par défaut (mais définir #2 sans #1 est une erreur).>

 485 <p.liste <arial chapitre> : nom de la balise ou métabalise PML du document source. Si plusieurs métabalises sont à prendre en compte, on peut écrire (par exemple) ‘<arialb \#1=préface+chapitre+postface,titre>’.>

 486 <p.liste <arial titre> : si le chapitre comporte un titre dans une balise distincte, la préciser ici. Si un style est défini sans cette entrée, accoler les deux virgules.>

 487 <p.liste <arial classe> : style css de l’entrée de la table des matières. Par défaut, le style normal des paragraphes (niveau 1) et listes (niveaux 2 et suivants) est utilisé.>

 488 <p.liste <arialb prefixe> : début du nom de tous les <arial id> créés (les id éventuellement préexistants sont conservés). Si pas spécifié, ’<arialb toc_>’ est la valeur par défaut.>

 489 <p.liste <arial Sommaire> : libellé du titre de la table des matières. Un littéral (cf. <a ##litteraux 5.4 Littéraux>) peut être fourni. Si rien n’est spécifié, le littéral <arialb \<@Contents\>> sera utilisé par défaut.>

 490 <espace_demi>

 491 <p <u Exemple de table des matières complexe :>>

 492 <code §partie \<h1 \<*\> partie\><br>

 493 ———›§chapitre \<h1 Chapitre \><br>

 494 ———›§titre \<p.titre\><br>

 495 ———›§sous_chapitre \<h2\><br>

 496 ———›§toc \<h1.sommaire #1=partie,titre,toc1 #2=chapitre,titre,toc2 #3=sous_chapitre,,toc3 \<@contents\>\>>

 497 <p Ceci génère une table à 3 niveaux.>

 498 <espace_demi>

 499 <encadré

 500 ———›<p <u Important :>>

 501 ———›<p.liste a. Les balises concernées, si elles n’ont pas déjà un id, en recevront un généré automatiquement.>

 502 ———›<p.liste b. Si un niveau est manquant (ex. absence de parties avec l’exemple ci-dessus), les entrées du niveau inférieur sont remontées d’un cran.>

 503 ———›<p.liste c. Si une entrée est présente mais sans texte, elle n’est pas prise en compte et ce qui vient dessous est remonté d’un cran.>

 504 ———›<p.liste d. À défaut de balise <arial \<toc\>> dans le document, l’existence d’une définition créera des id sur les balises concernées qui n’en auraient pas déjà.>

 505 ———›>

 506 <p <u Remarque :> Si le document est destiné à devenir un ePub, il est inutile de définir des classes pour les entrées de table des matières.>

 507

 508 <sous_chapitre 4.7. Section : \<section …\>>

 509 #-------------------------------------------

 510 <p Cette balise est standard en HTML5 et ne prend pas d’attributs, elle n’est qu’un regroupement – équivalente à <arial \<div #style=display:block …\>>.>

 511 <p Elle est néanmoins dotée en PML d’un statut spécial (mais qui n’affecte en rien son rôle en HTML).>

 512 <espace_demi>

 513 <p En effet, la construction des sommaires et l’affichage des notes ne sont correctement gérés que si :>

 514 <p.liste a. Les balises marquées dans les définitions <arial §toc> et <arial §note> (ainsi que <arial \<toc\>> ne sont pas indentées ;>

 515 <p.liste b. OU sont dans un document importé (dans lequel elles ne sont pas indentées), même si l’import lui-même est indenté ;>

 516 <p.liste c. OU si toutes ces balises sont regroupées dans une balise englobante <arial \<section …\>> qui peut être indentée (idem <arial \<import …\>>).>

 517 <p <u Note :> La balise <arial section> étant censée englober un grand bloc de texte PML, il est indispensable de la mettre seule sur une ligne, au risque que ce qui l’accompagne sur la même ligne disparaisse de la conversion.>

 518

 519 <chapitre 5. Balises de pré-traitement>

 520 #======================================

 521

 522 <p Ces balises permettent de conditionner la création du document HTML à certaines données, faciliter la mise en forme en évitant des répétitions, pouvoir obtenir plusieurs versions à partir d’un même document PML.>

 523

 524 <sous_chapitre 5.1. Insertion de blocs : \<import …\>>

 525 #-----------------------------------------------------

 526 <p Il est possible d’incorporer dans un document des éléments PML stockés séparément. Ils sont alors insérés à l’emplacement de leur appel et traités comme si le code faisait partie du document source.>

 527 <code \<import fichier.pml\>>

 528 <p <u Note :> le cas échéant, préciser le chemin si le fichier n’est pas dans le répertoire du document en cours de traitement.>

 529 <p Cette fonctionnalité est récursive, c’est-à-dire qu’un bloc importé peut lui-même contenir des imports.>

 530 <p <u Attention :> un import ne peut être conditionné par une constante, un retour d’appel Python ou une balise conditionnelle : si ce genre de condition est nécessaire, il doit être défini dans le fichier importé.>

 531 <encadré

 532 ———›<p <u Attention :> Un import peut figurer à l’intérieur d’un bloc, mais sous réserve que :>

 533 ———›<p.liste 1. cette balise soit seule sur la ligne source ;>

 534 ———›<p.liste 2. le contenu importé n’ait pas d’indentation initiale (càd qu’il doit pouvoir être importé hors d’un bloc ;>

 535 ———›>

 536

 537 <sous_chapitre 5.2. Python : \<py …\>>

 538 #-------------------------------------

 539 <p Il est possible d’incorporer du code généré par une fonction externe écrite en Python3, par exemple des données récupérées dans une base.>

 540 <code \<py fonction(paramètres…)\>>

 541 <p La balise entière sera remplacée par le contenu du retour de la fonction, lequel sera analysé en tant que code PML. Si la fonction ne renvoie rien, ou du code PML invalide, l’erreur est signalée (sauf si le retour est la valeur python <arial None>).>

 542 <espace_demi>

 543 <p <b <u Attention :>>>

 544 <p.liste 1. Tout ce qui serait ajouté derrière la fonction sera ignoré !>

 545 <p.liste 2. Les paramètres sont à mettre entre ' ' et séparés par des virgules.>

 546 <espace_demi>

 547 <p Cette balise peut évidemment être interne (et à ce moment renvoyer un simple texte).>

 548 <p Exemple avec une fonction devant renvoyer la date formatée en clair :>

 549 <code \<p.classe Nous sommes aujourd’hui le \<py fonc_date()\>.\>>

 550 <p Ces fonctions doivent être regroupées dans un module ‘modules.py’, par défaut dans le répertoire ‘fonctions’ de l’installation de PML.>

 551 <p Il est toutefois possible d’utiliser un autre emplacement, qui doit alors être précisé avec la constante ‘%modules’.>

 552 <espace_demi>

 553 <encadré

 554 ———›<p <u <b Possibilité très puissante :>>>

 555 ———›<p Sous réserve qu’il renvoie bien du code PML et non une valeur pour une constante, un appel Python peut renvoyer une liste. Dans ce cas, la ligne source contenant cet appel sera répétée autant de fois qu’il y a d’éléments dans l’objet retourné, chaque occurrence recevant un élément de la liste. Cela peut être extrêmement pratique pour remplir un tableau, par exemple.>

 556 ———›<p Attention : il est impératif pour que cela fonctionne de n’avoir qu’une seule balise \<py …\> sur la ligne source ! (Le problème ne se pose pas pour les retours de texte simple.)>

 557 ———›>

 558

 559 <sous_chapitre 5.3. Constantes : \<%xxx\>>

 560 #-----------------------------------------

 561 <p Plusieurs métabalises correspondent à des ‘constantes’ dont les valeurs dépendent uniquement des paramètres initiaux. Ces balises sont directement remplacées par la valeur correspondante et, à la différence des littéraux, n’acceptent aucun paramètre ni texte associé.>

 562 <p <arial \<lang\>> : remplace par le code langue en cours (ex : ‘<arial fr>’).>

 563 <p <arial \<document\>> : remplace par le nom du document traité, sans son chemin ni suffixe .pml.>

 564 <p <arial \<pmlroot\>> : remplace par le chemin menant à <arial pml.py>, permet d’éviter les chemins relatifs dans les liens locaux en positionnant tout vs <arial pml.py>.>

 565 <espace>

 566 <p Il est également possible de définir des constantes personnalisées :>

 567 <code §%isbn \<978-2-7544-2017-6\>>

 568 <p pour les définir, et :>

 569 <code \<%isbn\>>

 570 <p pour les utiliser. Remarquez le ‘%’ obligatoire comme premier caractère de la constante.>

 571 <p Dans l’exemple ci-dessus, toutes les balises <arial \<%isbn\>> du document seront remplacées par la valeur <arial 978-2-7544-2017-6>.>

 572 <espace_demi>

 573 <p <u Important :> ce remplacement ayant lieu avant tout traitement (hors imports), il est possible de placer une constante n’importe où, y compris dans une définition de métabalise, dans un bloc importé ou comme paramètre (ex : <arial #\<%isbn\>>). Inversement, on ne peut définir de constantes en retour d’un appel Python ni dans un bloc importé, elles ne seront pas reconnues comme telles.>

 574 <espace_demi>

 575 <p <u <b Attention :>> Lors de l’utilisation d’une constante, ne rien ajouter dans les délimiteurs sous peine qu’elle ne soit pas reconnue : ex. <arial \<%isbn est l’ISBN\>> sera rejeté comme « balise %isbn inconnue».>

 576 <p En outre, une constante doit impérativement être définie sur une seule ligne.>

 577 <espace_demi>

 578 <p <u Note :> un paramètre %… peut aussi recevoir une valeur à l’exécution, c’est-à-dire comme paramètre passé à l’appel de pmlexport. Cf. plus loin dans ce document.>

 579 <p Un paramètre personnalisé sans valeur définie sera remplacé par un texte de longueur nulle (avec affichage d’un message d’erreur).>

 580 <espace>

 581 <p <u Exemple des possibilités presque infinies :>>

 582 <code §%isbn \<\<py isbn('\<document\>')\>\>>

 583 <p appelle une fonction python qui reçoit le nom du document en paramètre et renvoie son code ISBN (par exemple lu dans une base de données), lequel devient la valeur de la constante %<arial isbn> utilisée ailleurs dans le document.>

 584 <p Remarquez les doubles délimiteurs : la paire extérieure délimite une constante, laquelle est générée par une balise, donc elle-même entre délimiteurs !>

 585 <p <u Attention :> <arial \<py …\>> est la seule balise autorisée à l’intérieur d’une constante !>

 586 <p <u Note :> dans le cas d’une constante pas nécessairement utilisée, pour éviter les messages d’avertissement une routine python peut lui donner la valeur <arial None> plutôt qu’un texte vide.>

 587 <p Une ou plusieurs constantes peuvent être définies (ou leur valeur modifiée) directement en ligne de commande avec l’option <arial -c %nom=valeur[ %nom2=valeur2[ …]]>>

 588 <encadré

 589 ———›<p <u Important :> Les constantes « remplies » par des appels Python sont analysées non pas dans l’ordre où elles apparaissent dans le document, mais dans l’ordre alphabétique. Donc, en cas d’interdépendance (ex. routine Python générant des valeurs récupérées par d’autres routines Python), veiller à les nommer de manière idoine (par exemple avec un préfixe commun suivi d’un numéro d’ordre).>

 590 ———›>

 591 <espace_demi>

 592 <p Il existe plusieurs autres façons de définir une constante :>

 593 <p.liste dans <arial pml.cfg>, avec une ligne <arial %constante=valeur> ;>

 594 <p.liste passée en paramètre dans l’appel de <arial pmlexport.py> sous la forme <arial %constante=valeur> ou <arial %constante> tout court, équivalent à un caractère blanc (attention : <arial %constante=> sans valeur ne sert à rien car constante vide≈constante nulle|non définie).>

 595 <espace_demi>

 596 <p <u Remarque :> une constante passée en paramètre sera ‘écrasée’ par une définition de la même dans pml.cfg ou le document pml. De même, une constante définie dans pml.cfg sera écrasée par une définition de la même dans le document.>

 597 <espace_demi>

 598 <encadré

 599 ———›<p <u <b Astuce :>> Afin d’éviter de remplir le fichier log avec des messages signalant des constantes vides ou inutilisées – cas de champs de saisie non remplis ou de constantes présentes dans un bloc \<incl\> non inclus –, mettre comme premier caractère '@' : une définition telle que <arialb §%@xyz \<…\>> ne donnera jamais lieu à avertissement quel que soit le statut de la constante. Naturellement, bien veiller lors de l’utilisation à ne pas oublier le préfixe '%' : <arialb \<%@xyz\>> !>

 600 ———›>

 601

 602 <sous_chapitre#litteraux 5.4. Littéraux : \<@xxxx\>>

 603 #---------------------------------------------------

 604 <p Il s’agit de pseudo-balises commençant par un '<arialb @>'. Ce nom, un mnémonique qui doit obéir aux règles de codification d’une balise ou métabalise, est remplacé par le libellé associé trouvé dans le fichier <arial locales/pml_xx.po> ou <arial locales/pml_xx.mo>, où <arial xx> est le code de la langue utilisée (‘<arial lang=xx>’ dans <arial pml.cfg >ou langue système par défaut).>

 605 <p Si le littéral n’a pas de correspondance, la balise entière apparaît telle quelle dans le HTML généré et un message d’erreur s’affiche à la génération.>

 606 <p Le texte d’un littéral peut contenir des paramètres et/ou un texte associé tels que définis au chapitre 3.>

 607 <espace_demi>

 608 <p <u Exemple :>>

 609 <p Si on a dans pml_fr.po le mnémonique ‘test’ avec le libellé ‘C’est \<*\> qu’on teste.’, et dans pml_en.po le libellé ‘Here, \<*\> is tested.’>

 610 <code \<@test pml\>>

 611 <p donnera respectivement :>

 612 <code C’est pml qu’on teste.<br>

 613 ———›Here, pml is tested.>

 614 <p.just0 selon la langue en cours.>

 615 <espace>

 616 <p S’il faut plus d’un élément au sein du texte, il faut alors utiliser les paramètres, soit positionnels, soit nommés.>

 617 <espace_demi>

 618 <p <u Exemple :>>

 619 <p Si ‘countdown’ correspond en français à ‘Il vous reste \<*1\> minutes et \<*2\> secondes.’,>

 620 <code \<@countdown #2 #59\>>

 621 <p.just0 donnera :>

 622 <code Il vous reste 2 minutes et 59 secondes.>

 623 <p Ou bien, si ‘countdown’ correspond en français à ‘Il vous reste \<*mn\> minutes et \<*s\> secondes.’,>

 624 <code \<@countdown #s=59 #mn=2\>>

 625 <p.just0 donnera la même chose que plus haut.>

 626 <espace_demi>

 627 <p <u Note :> le libellé d’un littéral peut contenir diverses balises PML (gras, italique, lien, image…), elles seront traitées normalement.>

 628 <espace_demi>

 629 <p <u Remarque :> Les littéraux présentent essentiellement un intérêt pour des pages destinées à Internet. Si l’objectif est un ePub, par définition monolingue, le besoin n’est guère présent.>

 630

 631 <sous_chapitre 5.5. Traitement conditionnel \<incl …\>, \<excl …\>, \<else …\>>

 632 #------------------------------------------------------------------------------

 633 <p À l’aide de constantes, il est possible de conditionner la présence ou l’exclusion de parties du document. Ceci permet de créer plusieurs versions à partir d’un même fichier .pml (par exemple, un extrait de roman pour un epub, voir exemple en fin de cette section).>

 634 <p Il y a deux modes d’utilisation.>

 635 <espace_demi>

 636 <p 1. Incorporation directe de la partie concernée :>

 637 <code \<incl %param=valeur[ %param=valeur …] \<balise …\>\>>

 638 <p La balise ne sera présente dans le document que si chacun des <arial %param> (qui peuvent être aussi une constante fixe telle <arial \<lang\>> ou <arial \<document>\>) a la valeur indiquée. <arial \<excl> fera l’inverse : la balise sera présente sauf si le ou les paramètres possèdent tous la valeur indiquée.>

 639 <p Si la condition pour une constante est basée sur l’existence ou la valeur non nulle (c.à.d. contenant au moins un caractère) du paramètre, il suffit de ne pas mettre de comparaison :>

 640 <code \<incl %param \<balise …\>\>>

 641 <p.just0 prendra en compte la balise si <arial %param> est défini et non nul, quelle que soit sa valeur par ailleurs.>

 642 <p Dans le cas de vérification sur l’absence (ou la valeur nulle) d’une constante, les deux notations ci-dessous sont équivalentes :>

 643 <code \<excl %param …\><br>

 644 ———›\<incl %param- …\>>

 645 <p L’intérêt de la seconde notation réside surtout dans l’usage de plusieurs constantes dans une même condition :>

 646 <code \<incl %param1 %param2- …\>>

 647 <p.just0 correspond à la condition "si param1 et non param2 …".>

 648 <espace>

 649 <p 2. Délimitation :>

 650 <code \<incl %param=valeur[ %param=valeur …]\><br>

 651 ———›<br>

 652 ———›\<incl\>>

 653 <p Ici, en l’absence de balise associée, c’est toute la partie du document comprise entre les deux <arial \<incl> qui ne sera présente que si les paramètres correspondent.>

 654 <p Chaque <arial \<incl> ou <arial \<excl> est traité en séquence indépendamment des précédents. Toute condition remplie activera l’exclusion ou l’inclusion de la suite. Un <arial \<incl\>> inconditionnel rétablira l’état initial (pas de <arial \<excl\>> inconditionnel, qui équivaudrait à supprimer systématiquement tout ce qui suit et ne se serait donc guère pertinent).>

 655 <espace>

 656 <p Astuce : il est également possible d’inverser une condition, en remplaçant ‘=’ par ‘!=’ ou ‘≠’ (ou en ajoutant un ‘-’ à la fin d’une constante sans valeur associée). De même, on peut accepter une sous-valeur avec '~=' ou '≃' : une constante contenant 'en-GB' validera une telle comparaison avec 'en'.>

 657 <p Note : une inclusion ou exclusion avec balise associée sera traitée indépendamment de l’état inclusion ou exclusion global en cours.>

 658 <p Exemple pour un ePub (<arial titre_principal>, <arial centre> et <arial àsuivre> sont bien sûr des métabalises maison) :>

 659 <code<br>

 660 ———›\<titre_principal Titre de livre\><br>

 661 ———›\<incl %extrait \<centre \<b (extrait)\>\>\><br>

 662 ———›<br>

 663 ———›\<incl %extrait \<àsuivre (à suivre)\>\><br>

 664 ———›\<excl %extrait\><br>

 665 ———›>

 666 <p Si <arial %extrait> n’est pas mis dans la ligne de commande, on génère l’ePub normal du livre complet.>

 667 <p Si <arial %extrait> est spécifié, un ePub réduit est généré, avec « (extrait) » sous le titre, et « (à suivre) » en fin de document, à la place de tout ce qui suit la balise <arial excl>.>

 668 <espace>

 669 <p La balise <arial else>, qui ne prend aucune constante, ne joue qu’un rôle complémentaire :>

 670 <p.liste a. En l’absence de conditions <arial incl> (directes ou en délimiteurs) la précédant, <arial else> se comporte comme un <arial incl> inconditionnel (elle est en fait inutile).>

 671 <p.liste b. Précédée par une ou plusieurs conditions <arial incl>, son contenu ou ce qui la suit sera pris en compte si, et uniquement si, aucune des conditions précédentes n’a été validée.>

 672 <p Une balise <arial \<incl\>> ferme un groupe <arial else> tout comme n’importe quel <arial \<incl …\>>.>

 673 <p Exemple :>

 674 <code \<incl %src=abc\><br>

 675 ———›<br>

 676 ———›\<incl %src=def\><br>

 677 ———›<br>

 678 ———›\<else\><br>

 679 ———›\<p Erreur\><br>

 680 ———›\<incl\>>

 681 <p.just0 affichera 'Erreur' si la constante <arial %src> ne vaut ni 'abc' ni 'def'.>

 682 <espace>

 683 <encadré

 684 ———›<p <u À noter :> Les balises <arial incl>, <arial excl> et <arial else> ne suivent apparemment pas la règle d’indentation en vigueur dans HTML et XML, à savoir qu’une balise ne doit affecter que ce qui est inclus entre ses délimiteurs de début et fin.>

 685 ———›<p Toutefois, il s’agit ici de balises de prétraitement ayant un rôle particulier, puisque ne jouant pas sur l’environnement, mais sur la présence ou l’absence, une nouvelle condition pouvant altérer la précédente.>

 686 ———›<p Il était donc plus simple de faire une petite entorse en leur faisant impacter non pas le contenu, mais la suite.>

 687 ———›>

 688

 689 <sous_chapitre 5.6. directives HTTP \<http …\>>

 690 #----------------------------------------------

 691 <p Cette balise permet de définir des directives http, qui seront émises avant le document lui-même. Aucun contrôle n’est effectué sur leur contenu (avec risque de « Internal error 500 » en cas de contenu invalide).>

 692 <p Il est ainsi possible d’effectuer de nombreux pré-traitements, comme par exemple une redirection.>

 693 <espace_demi>

 694 <p <u Exemple :>>

 695 <code \<pml\><br>

 696 ———›§%ok \<\<py valide('\<%user\>')\>\>\><br>

 697 ———›\<incl %ok!=oui \<http Location: http://www.pml.ovh/\>\><br>

 698 ———›…code de la page…>

 699 <p.just0 n’affichera la page que si le paramètre 'user' a été reçu et validé par la routine python. Dans tous les autres cas, on est renvoyé vers la page principale du site.>

 700 <espace>

 701 <p L’usage des directives http est évidemment réservé aux pages Internet… et aux « webmestres » chevronnés.>

 702 <p Une liste de ces directives ici : <a #https://en.wikipedia.org/wiki/List_of_HTTP_header_fields>>

 703 <espace_demi>

 704 <p <u Note :> Les directives "<arial Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0>" et "<arial Content-type: text/html>" sont automatiquement placées devant le début du document Internet proprement dit, elles ne sont donc jamais à spécifier.>

 705

 706

 707 <sous_chapitre 5.7. Mises à jour <i <rouge (à faire)>>>

 708 #------------------------------------------------------

 709 <p Un élément ajouté ou supprimé peut être balisé ainsi :>

 710 <code texte \<- enlevé\>\<+ ajouté\>>

 711 <p Cependant, la génération HTML ne pourra donner que :>

 712 <code texte ajouté>

 713 <p C’est pourquoi on peut ajouter une indication derrière le signe :>

 714 <code texte \<-1 enlevé\>\<-2 \<+1 ajouté\>\>\<+2 modifié\>>

 715 <p Ainsi, la génération HTML pourra être différente selon la valeur de l’option -v xx spécifié dans la ligne de commande :>

 716 <p <arial -v 0> :>

 717 <code texte enlevé>

 718 <p <arial -v 1> :>

 719 <code texte ajouté>

 720 <p <arial -v 2> (ou \>2) :>

 721 <code texte modifié>

 722 <p Pour un meilleur traitement, il est possible d’associer des données plus parlantes dans la zone des métabalises :>

 723 <code §1 \<20170109\>>

 724 <p ou>

 725 <code §1 \<lundi\>>

 726 <p Ainsi, <arial -v 20170109> (ou <arial -v lundi>) sera équivalent à <arial -v 1>.>

 727 <p Attention, seules les métabalises uniquement constituées d’un nombre sont associables à des repères de mises à jour.>

 728

 729 <chapitre 6. Les outils>

 730 #=======================

 731

 732 <p Compte tenu de ses _usages multiples, PML est fourni en plusieurs « colis » :>

 733 <p.liste A. Un pack <b base> contenant les outils pour importer/exporter/créer du HTML ou des ePub. Son installation se fait simplement en décompressant l’archive dans un répertoire au choix (qu’il est bon d’ajouter dans la liste des « path » du système pour simplifier les appels par la suite).>

 734 <p.liste <u Contenu :>>

 735 <p.liste2 Les programmes <arial pmlimport.py>, <arial pmlexport.py>, <arial htmlepub.py>.>

 736 <p.liste2 Un fichier de configuration <arial pml.cfg>. C’est dans ce fichier qu’on définit quelques paramètres d’installation, comme la langue et le chemin de l’outil epubcheck…>

 737 <p.liste2 Une feuille de style de métabalises <arial pml.pss>, qui contient quelques redéfinitions « générales » (pour le français).>

 738 <p.liste2 Un sous-répertoire <arial fonctions>, qui contient les fonctions partagées par les programmes susmentionnés et un fichier <arial modules.py> destiné à accueillir les fonctions python utilisateur. C’est également là qu’il faudra mettre les fonctions externes pour ceux qui développeront des choses supplémentaires, telles des accès à une base de données.<br>Le fichier fourni contient un exemple de lecture d’une base de données afin de renvoyer les caractéristiques d’un livre dans des constantes en vue créer un ePub.>

 739 <p.liste2 Un sous-répertoire <arial locale>, qui contient les littéraux définis pour un contexte international (cf. métabalise \<@…\>).>

 740 <espace_demi>

 741 <p.liste B. Un pack <b web> pour les appications de site Internet (ou Intranet, ne soyons pas chauvins).>

 742 <p.liste <u Contenu :>>

 743 <p.liste2 Le programme <arial pml.py> d’interface pour les requêtes Internet.>

 744 <p.liste2 Un fichier de configuration <arial pml.cfg>. C’est dans ce fichier qu’on définit quelques paramètres d’installation, comme la langue. (idem pack base)>

 745 <p.liste2 Une feuille de style de métabalises <arial pml.pss>, qui contient quelques redéfinitions « générales » (pour le français). (idem pack base)>

 746 <p.liste2 Un fichier <arial pml.alias> d’exemple (cf. plus loin dans ce chapitre).>

 747 <p.liste2 Un fichier <arial .htaccess> avec les instructions permettant à Apache de traiter des documents PML.>

 748 <p.liste2 Un fichier <arial 404.pml>, appelé quand la page demandée n’est pas trouvée. il est évidemment personnalisable.>

 749 <p.liste2 Un sous-répertoire <arial fonctions>, qui contient les fonctions partagées par les programmes susmentionnés et un fichier <arial modules.py> destiné à accueillir les fonctions python utilisateur. C’est également là qu’il faudra mettre les fonctions externes pour ceux qui développeront des choses supplémentaires, telles des accès à une base de données. (idem pack base, sauf <arial modules.py> qui ne contient pas les mêmes exemples. Ici, c'est la conversion d’un code source PML en document (toujours PML) qui affichera ce code source avec coloration syntaxique. Cf <@show_PML_code> et <@understand_PML> sur <a #http://www.pml.ovh>.)>

 750 <p.liste2 Un sous-répertoire log, qui recevra les messages émis par l’export pml→html dans un environnement de navigation internet (avertissements, erreurs, plantages…)>

 751 <espace_demi>

 752 <p.liste C. La documentation sous forme d’ePub.>

 753 <espace>

 754 <p <u Note 1 :> il est recommandé d’installer l’utilitaire <arialb epubcheck>, téléchargeable sur <a #https://github.com/IDPF/epubcheck/releases>.>

 755 <p <u Note 2 :> Les utilisateurs Windows doivent également installer :>

 756 <p.liste Python 3.6, téléchargeable sur <a #https://www.python.org/downloads/windows/>.>

 757 <p.liste Java, dispo sur <a #https://www.java.com/fr/download/manual.jsp> (prendre une version hors ligne).>

 758 <encadré

 759 ———›<p <u Note 3 :> l’intérêt de PML étant de faciliter la mise à jour|mise au point de documents, un bon éditeur de texte est donc recommandé. Personnellement, je conseille KomodoEdit : <a #http://www.activestate.com/komodo-ide/downloads/edit>.>

 760 ———›<p Il a, entre autres points forts (coloration syntaxique pour de nombreux langages, Unicode pleinement supporté, etc.) le double avantage d’exister pour Windows, Mac et Linux… et d’être gratuit pour un usage personnel. (Pour la coloration syntaxique, je tâcherai dans un avenir pas trop lointain de lui adjoindre la reconnaissance de PML.)>

 761 ———›>

 762

 763 <sous_chapitre 6.1. Installation>

 764 #--------------------------------

 765 <p.just0 <b Windows (W7 minimum) :>>

 766 <p Installer <arial python 3.5> ou supérieur depuis <a #https://www.python.org/downloads/windows>.>

 767 <p Installer <arial win-unicode-console>, soit directement avec <arial pip install win-unicode-console>, ou télécharger le module depuis la page <a #https://pypi.org/project/win_unicode_console/> et l’installer par <arial pip install win_unicode_console-0.5.zip>. Ne pas oublier de cocher la case pour ajouter le chemin de Python dans le <arial Path>.>

 768 <p Cela fait, l’appel de tout programme python en ligne de commande doit simplement être précédé de ‘python’.>

 769 <espace_demi>

 770 <p.just0 <b Linux :>>

 771 <p Rien à installer, python et java sont en principe de base (à vérifier, peut n’être pas vrai pour toutes les plates-formes).>

 772 <p L’appel de tout programme python en ligne de commande doit simplement être précédé de ‘python3’ (‘python’ tout court appelle python 2.7, non compatible).>

 773 <espace_demi>

 774 <p.just0 <b Tous systèmes :>>

 775 <p Les modules python suivants peuvent être nécessaires et devront éventuellement être installés :>

 776 <p <arialb polib> : à installer, indispensable pour la gestion des littéraux et des messages.>

 777 <p <arialb PIL> : indispensable pour htmlepub. Attention, prendre <arial python-pil> (pour python3) et non <arial pillow> (python2, non compatible).>

 778 <p <arialb mysql.connector> : pour toute fonction utilisateur devant accéder à une base de données.>

 779 <espace_demi>

 780 <p.just0 <b Serveur internet :>>

 781 <p Le pack doit simplement être décompressé dans le répertoire racine du site.>

 782 <p Que ce soit sur une machine locale ou raccordée au réseau, l’utilisation en mode web de PML nécessite que ce serveur soit configuré pour exécuter les fichiers Python.>

 783 <p Il est également indispensable que le module ‘<arial rewrite>’ d’Apache soit activé (ex. par la commande en ligne ‘<arial a2enmod rewrite>’).>

 784

 785 <sous_chapitre 6.2. Le fichier de configuration pml.cfg>

 786 #-------------------------------------------------------

 787 <p Simple suite de valeurs sous la forme :>

 788 <code code = valeur>

 789 <p Peut contenir des commentaires avec un # en début de ligne. Ce fichier est d’ailleurs ainsi auto-documenté. Il est fourni avec des valeurs par défaut (Linux pour les chemins d’accès).>

 790

 791 <sous_chapitre 6.3 Les fichiers de littéraux et messages>

 792 #--------------------------------------------------------

 793 <p Fichiers suffixées en .mo (format binaire) contenant des littéraux associés à des mnémoniques dans diverses langues. Tous placés dans le répertoire locale, ils doivent s’intituler msg_xx.mo (pour les messages) et pml_xx.mo pour les littéraux utilisateur.>

 794 <p Un petit utilitaire ‘locales_gen.py’ permet de générer/mettre à jour ces fichiers à partir d’un fichier source unique locales.txt (fourni et auto-documenté).>

 795

 796 <sous_chapitre 6.4. L’utilitaire pmlimport.py>

 797 #---------------------------------------------

 798 <p Pour convertir un document HTML ou EPUB en document PML :>

 799 <code python[3] [chemin/]pmlimport.py [-feuille.pss] [document.html|document.epub] [-o fichier[.pml]][ -ignore classe1[,classe2…]] [ -indent]>

 800 <p<arial -feuille.pss>’ est une option de spécification d’une feuille de style .pss à prendre en compte pour la conversion (en sus de <arial pml.pss>, toujours exploité). Le cas échéant, préciser son chemin. Il peut s’agir de définitions « temporaires » aidant au remplacement de balises ou attributs qui seront différents par la suite (en d’autres termes, des métabalises utilisées pour pmlimport n’auront pas nécessairement la même définition avec une autre feuille de style utilisée par pmlexport). Si cette feuille se trouve dans le répertoire défini par la constante<arial %scripts>, écrire <arial -[%scripts]feuille.pss> (les caractères \< et \> posent problème en ligne de commande).>

 801 <p Par défaut, le fichier PML généré porte le même nom de base que le source HTML : abc.pml→abc.html. Il est toutefois possible de spécifier un autre nom dans la ligne de commande.>

 802 <p <arial -ignore> permet de définir une liste de classes contenues dans l’ePub ou le document HTML et correspondant à des balises à ne pas conserver (nettoyage de documents inutilement surchargés). Par défaut, seules les balises <arial span> sont concernées. Il est toutefois possible de préciser une autre balise en mettant explicitement balise.classe. Ex.>

 803 <code ignore calibre4,i.calibre6>

 804 <p supprimera les balises <arial \<span class="calibre4" …\>> et <arial \<i class="calibre6" …\>>. Ce qui se situe entre les <arial \<span …\>> et <arial \</span\>> est évidemment préservé.>

 805 <p Souvent des balises inutiles sont numérotées en séquence. Pour simplifier, on peut mettre un ‘ ?’ là où peut figurer un chiffre. Ainsi, <arial -ignore calibre??> ignorera toutes les classes de <arial calibre00> à <arial calibre 99> (mais pas celles avec 1 ou 3 chiffres).>

 806 <p <arial -indent> force la restructuration du code indépendamment de l’assemblage HTML. Ceci est extrêmement utile en cas de document HTML bâti n’importe comment et souvent illisible, car apportant la lisibilité nécessaire à la compréhension.>

 807 <espace>

 808 <p Attention : les métabalises avec texte ne sont reconnues que si elles sont effectivement sur une seule ligne.>

 809 <p Toute balise HTML, dans le cas général :>

 810 <code \<balise[ class="abc"][ id="def"][ attribut="ghij"]\>texte\</balise\>>

 811 <p est convertie comme suit :>

 812 <p 1. Une métabalise reprenant la définition, avec un commentaire signalant le nombre d’occurrences (utile pour le nettoyage) :>

 813 <code §balise_abc_n \<balise.abc[#def][ #attribut=ghij]\><br># Utilisée 5 fois>

 814 <p 2.La balise PML proprement dite :>

 815 <code \<balise_n texte\>>

 816 <p <u Remarques :>>

 817 <p.liste <arial n>’ est une numérotation différenciant les variantes de ‘balise’ utilisées (balise_0, balise_1, etc.). En général, le nom de la métabalise reprend juste celui de la classe de la balise html. Dans le cas où la même classe servirait à plusieurs balises différentes, le nom de la balise devient alors 'classe_balise[_n]'.>

 818 <p.liste Si une définition est présente dans <arial pml.pss> ou la feuille de style donnée en paramètre, c’est son nom qui est utilisé et aucune métabalise nouvelle n’est définie.>

 819 <p.liste Les contenus d’éventuelles balises <arial style> ou <arial script> sont mis entre triples « apostrophes » et laissés intacts dans le code généré.>

 820 <p.liste Si le document source est un ePub, le fichier PML obtenu ainsi que la (ou les) feuille(s) de style et l’image de couverture, sont copiés dans le répertoire courant. Les images sont amenées avec le même chemin relatif vs le texte, donc soit dans le répertoire courant, soit (le plus souvent) dans un sous-répertoire.>

 821 <p.liste Les attributs ayant des valeurs normalement uniques (href, src, data-…) ne sont jamais incorporés dans une métabalise, afin de ne pas multiplier inutilement les définitions.>

 822 <espace>

 823 <encadré

 824 ———›<p.just0 <b Points forts :>>

 825 ———›<coché Si, comme souvent, une même balise avec les mêmes attributs apparaît 36 fois dans le document HTML (ce qui est toujours le cas dans les conversions Word→HTML), une seule redéfinition est faite, ce qui :>

 826 ———›<p.liste2 <b a.> raccourcit considérablement le code résultant, et…>

 827 ———›<p.liste2 <b b.> permet d’identifier très vite les balises redondantes (pas identiques mais presque) et de simplifier très facilement le code dans le document PML.>

 828 ———›<coché L’usage d’une feuille de style .pss permet de générer directement la métabalise voulue, d’où simplification du nettoyage et gain de temps important.>

 829 ———›>

 830

 831 <sous_chapitre 6.5. L’utilitaire pmlexport.py>

 832 #---------------------------------------------

 833 <p Pour convertir un document PML en document HTML :>

 834 <code python[3] [chemin/]pmlexport.py document.pml [-o fichier[.html]] [-epub|-epub2|epub3] [%constante=valeur]…>

 835 <p<arial -epub>’ est une option qui a pour effet de lancer htmlepub sitôt la création du document HTML achevée. <arial -epub> et <arial -epub2> lancent la fabrication d’un ePub2, <arial -epub3> celle d’un ePub3 (bien que cette norme soit encore très mal/peu supportée par les logiciels de lecture).>

 836 <p Par défaut, le fichier HTML généré porte le même nom de base que le source PML : abc.pml→abc.html. Il est toutefois possible de spécifier un autre nom dans la ligne de commande.>

 837 <p Note : si ce nom fourni n’est pas suffixé, ou suffixé avec autre chose que <arial .htm> ou <arial .html>, le suffixe sera forcé en <arial .html>.>

 838 <p Remarque : comme on peut le voir ci-dessus, il est possible de passer des constantes en paramètres (et pas qu’une seule).>

 839 <espace>

 840 <encadré

 841 ———›<p.just0 <b Points forts :>>

 842 ———›<coché Les fermetures de balises manquantes ou excédentaires sont identifiées et compensées, ainsi le HTML généré est toujours propre (même s’il peut ne pas être conforme au souhait du fait des erreurs rencontrées).>

 843 ———›<coché Création d’une table des matières pouvant être très structurée (jusqu’à 3 niveaux) grâce à une simple métabalise (cf. <b 4.D> plus haut).>

 844 ———›<coché Positionnement et numérotation automatique des notes (cf. <b 4.C> plus haut), adaptation ePub3 prévue (infobulles|pop-up) sans qu’il soit besoin de toucher au code PML.>

 845 ———›<coché Gestion des petites capitales tenant compte du mauvais|non support de l’attribut de style ‘<arial small-caps>’.>

 846 ———›<coché Nettoyage du code par suppression des balises de type <arial span> (<arial b>, <arial i>, <arial sup>, <arial inf>, etc.) ne contenant aucun caractère pour lequel la spécification aurait un sens ; chaque correction est signalée pour permettre le nettoyage dans le source PML.>

 847 ———›<coché Suppression des ‘<arial id>’ inutiles (non référencés) et ‘<arial href>’ locaux invalides (lien vers id non défini), avec signalisation.>

 848 ———›<coché Signale les classes non définies dans une feuille <arial .css>, ainsi que les métabalises directement définies dans le document mais non utilisées.>

 849 ———›<coché Capacité d’appel de routines en Python pour incorporer de l’information ou vérifier du code.>

 850 ———›<coché L’usage combiné de constantes dans la ligne de commande et des balises <arial incl|excl> permet de générer des HTML différents à partir d’un unique PML.>

 851 ———›<coché L’usage de littéraux permet de créer des pages HTML dans diverses langues à partir d’un unique PML.>

 852 ———›>

 853

 854 <sous_chapitre 6.6. L’utilitaire htmlepub.py>

 855 #--------------------------------------------

 856 <p Pour convertir un document HTML en livre ePub :>

 857 <code python[3] [chemin/]htmlepub.py document.html [-epub3]>

 858 <p<arial -epub3>’ indique que le résultat souhaite doit être un ePub3. Par défaut, c’est un ePub2 qui est créé. <rouge (Régression temporaire : ne fonctionne plus pour ePub3)>>

 859 <espace>

 860 <encadré

 861 ———›<p.just0 <b Points forts :>>

 862 ———›<coché Reconnaît un chapitre contenant une table des matières (notamment créée par pmlexport) et s’en sert pour celle de l’ePub. À défaut, la crée de toutes pièces, en utilisant les balises <arial \<h1> dotées d’un ‘<arial id>’. cf. paramètre ‘tocid’ dans pml.cfg.>

 863 ———›<coché Se sert des ‘meta’ pour enregistrer correctement les diverses caractéristiques d’un ePub (auteur(s), traducteur(s), description, etc.).>

 864 ———›<coché Fusionne toutes les feuilles de style <arial .css> en ne conservant que les styles effectivement utilisés : pas de définitions inutiles.>

 865 ———›<coché En fin de traitement, appelle epubcheck (si installé) pour vérifier la conformité du livre obtenu.>

 866 ———›>

 867 <espace_demi>

 868 <p Prévu : une option pour incorporer les polices de caractères, mais en les réduisant aux sous-ensembles effectivement utiles au livre.>

 869 <p La plupart des données informatives d’un ePub peuvent être insérées directement dans le document HTML en tant que <arial \<meta>.>

 870 <p Ex :>

 871 <code \<meta name="type" content="Science-fiction" /\><br>

 872 ———›\<meta name="publisher" content="Éditions de chez moi" /\><br>

 873 ———›\<meta name="description" content="Description du contenu de l’ouvrage//sur deux paragraphes" /\><br>

 874 ———›\<meta name="creator:aut" content="Jean Dupont" /\><br>

 875 ———›\<meta name="language" content="fr" /\><br>

 876 ———›\<meta name="title" content="Mon livre à moi" /\><br>

 877 ———›\<meta name="date" content="2017-12-31" /\>>

 878 <p ou bien, en partant d’un document PML :>

 879 <code \<meta #name=type #content=Science-fiction\><br>

 880 ———›\<meta #name=publisher #content=Éditions\ de\ chez\ moi\><br>

 881 ———›\<meta #name=description #content=\'''Description du contenu de l’ouvrage//sur deux paragraphes\'''\><br>

 882 ———›\<meta #name=creator:aut #content=Jean\ Dupont\><br>

 883 ———›\<meta #name=language #content=fr\><br>

 884 ———›\<meta #name=title #content=Mon\ livre\ à\ moi\><br>

 885 ———›\<meta #name=date #content=2017-12-31\>>

 886 <p (Notez qu’il est possible dans ce contexte d’éviter d’échapper les espaces en mettant le texte entre triples « apostrophes »)>

 887 <p Les éléments pouvant contenir plusieurs paragraphes (notamment <arial description>) doivent avoir les sauts de paragraphes repérés par des // et non par des retours de ligne réels.>

 888 <p Les valeurs de « name » sont décrites dans le document:>

 889 <p <a #http://www.idpf.org/epub/20/spec/OPF_2.0.1_draft.htm#Section2.2>>

 890 <p Les données ayant un attribut « <arial opf:role> » dans l’ePub (<arial creator> et <arial contributor>) peuvent s’écrire très simplement en PML (ou équivalent HTML) :>

 891 <code \<meta name="creator" opf:role="xyz" … /\><br>

 892 ———›= \<meta #name=creator:xyz …\><br>

 893 ———›= \<meta name="creator:xyz" … /\>>

 894 <p La liste des codes en trois lettres reconnus figure dans le même document susmentionné.>

 895

 896 <sous_chapitre 6.7. routines Python utiles>

 897 #------------------------------------------

 898 <p <i Ceci s’adresse évidemment en premier lieu à ceux et celles qui implémenteraient du code Python pour exploiter au mieux les capacités de PML.>>

 899 <h3 fonctions de trace>

 900 <p Le fichier <arial fonctions/trace.py> contient deux fonctions utiles pour aider au débogage :>

 901 <p.liste 1. <arialb trace.log> fonctionne comme un <arial print>, sauf qu’elle n’accepte qu’un seul paramètre (donc bien formater l’ensemble de ce qui lui est passé) : <arial trace.log(texte)>.>

 902 <p.liste 2. <arialb trace.val> prend deux paramètres :>

 903 <p.liste2 a. une chaîne de caractère contenant le nom de la variable (ou des variables, séparés par des virgules) dont on veut connaître la valeur ;>

 904 <p.liste2 b. la fonction <arialb locals()>, indispensable pour que Python utilise bien les variables du fichier en cours et non d’éventuelles variables de même nom définies ailleurs.>

 905 <p.liste <arial trace.val> donnera les valeurs de toutes les variables données dans le premier paramètre, quel que soit leur format, avec '???' pour celles qui ne seraient pas identifiées (donc sans plantage même en cas d’erreur de nom). Ex : <arial trace.val('var1,var2',locals())>. Restriction : ne pas mettre d’élément de tableau ave un indice lui-même variable, genre <arial tab[xt]>.>

 906 <espace_demi>

 907 <p <arial trace.log> et <arial trace.val> enregistrent les résultats dans un fichier log (dans le répertoire de même nom, associés à jun horodatage et au fichier et au numùéro de la ligne où elles ont été appelées.)>

 908 <p <arial fonctions/trace.py> est défini en standard pour l’environnement pml destiné à Internet. Pour <arial pmlexport.py>, qui affiche tout dans le terminal, son utilité est moindre, <arial print> étant disponible.>

 909 <h3 tri naturel>

 910 <p Le fichier <arial fonctions.fonctionssort.py> contient un puissant utilitaire permettant de trier des données dans un ordre naturel pour l’esprit humain. il utilise les descriptions Unicode enregistrées dans le système.>

 911 <p.liste La séquence <arial Lefèvre / Lefebvre / Le Fèvre / Lefébure> sera triée en <arial Lefébure / Lefebvre / Le Fèvre / Lefèvre>. (Les espaces, accents, etc. sont traités comme des variantes – œ est classé comme 'oe', ß comme 'ss', etc.) Seule restriction : non testé pour les systèmes non alphabétiques.>

 912 <p.liste La séquence <arial a5 / A10 / a9b> sera triée en <arial a5 / a9b / A10> (toute suite de chiffres est traitée comme un nombre).>

 913 <espace_demi>

 914 <p. La fonction <arial naturalsort> peut recevoir plusieurs paramètres (en tri « standard », seul le premier, au format <arial list> est obligatoire) :>

 915 <p.liste Le deuxième doit être une liste (ou une liste de listes, cf. 4<e> paramètre) de mots considérés comme des préfixes et déplacés en fin de séquence pour l’ordre de tri. ainsi, avec une liste d’articles comme <arial le, la, les, du, de la, des, l’…>, C'est le mot qui suit l’article qui sert au classement : <arial La gauche / Le milieu / La droite / L’envers> seront triés comme <arial La droite / L’envers / La gauche / Le milieu>.>

 916 <p.liste Le troisième est <arial compare=True> (étant par défaut <arial compare=False>). Avec <arial True>, le tri renvoie non pas une, mais deux listes, la seconde étant les chaînes telles que reformatées pour le tri. Peut être utile pour comprendre ce qui s’est passé si le résultat n’est pas celui escompté – ce qui ne signifie pas que le tri est mauvais, juste que sa logique n’a pas été bien comprise.>

 917 <p.liste — Le quatrième est <arial sep='x'> où 'x' est un caractère de séparation permettant de trier comme si on donnait plusieurs colonnes. Par exemple, <arial sep='/'> triera correctement des chemins de répertoires (Linux ou Mac, sachant que Windows demandera '\\\\' – hélas le caractère d’échappement standard, donc à doubler).>

 918 <espace_demi>

 919 <p Pour les dictionnaires, <arial naturalsortDict> (qui ne prend qu’un seul paramètre renvoie les clés du dictionnaire passé en paramètre selon la logique décrite plus haut.>

 920 <espace_demi>

 921 <p Cet outil est offert en bonus, à chacun de l’importer dans ses modules Python – il est indépendant et n’est pas réservé à PML !>

 922

 923 <chapitre 7. L’utilitaire pml>

 924 #=============================

 925

 926 <p Ce programme, utilisé dans le traitement de requêtes de pages Internet, permet, à l’aide de quelques redirections à définir pour Apache sur le serveur, de travailler avec des fichiers .pml aussi nativement que s’il s’agissait de pages .html ou .php.>

 927 <p Ainsi une requête <arial http://www.monsiteamoi.fr/accueil.pml> enverra au navigateur le flux au format html issu de l’export pml→html.>

 928 <espace>

 929 <encadré

 930 ———›<p.just0 <b Points forts :>>

 931 ———›<coché Permet d’utiliser des fichiers pml aussi facilement que s’il s’agissait de html, php, py…>

 932 ———›<coché Contrairement aux programmes php ou python, même une erreur grave s’affichera à l’écran plutôt qu’un ‘Internal error 500’ souvent sans informations utiles dans error.log d’Apache.>

 933 ———›<coché La puissance des métabalises (et notamment la possibilité de faire appel à des routines python, ce qui inclut des accès base de données) permet d’avoir des pages dynamiques et quasiment de créer des sites complets.>

 934 ———›>

 935 <espace>

 936 <p <arial pml.py> doit être installé dans le répertoire racine du site. Il est livré avec un <arial .htaccess> contenant les commandes Apache indispensables pour que les fichiers .pml soient reconnus, ainsi que 2 pages en pml : <arial index.pml> et <arial 404.pml>. La première permet de tester le bon fonctionnement en saisissant dans la barre d’adresse du navigateur :>

 937 <code http://chemin_vers_pml/index.pml>

 938 <p ou, en local :>

 939 <code localhost/chemin_vers_pml/index.pml>

 940 <p où le niveau de base <arial http://> ou <arial localhost/> est celui défini dans la configuration du serveur (en local sous Linux, souvent <arial /var/www>) et <arial chemin_vers_pml> le ou les sous_répertoires menant à celui qui contient <arial pml.py>.>

 941 <p <arial 404.pml> est la page par défaut qui s’affiche (dans la langue du système ou celle spécifiée dans <arial pml.cfg>) quand <arial xyz.pml> n’existe pas.>

 942 <espace>

 943 <p Les sous_répertoires sont parfaitement reconnus. La requête :>

 944 <code localhost/chemin_vers_pml/rep1/rep2/pagerep3.pml>

 945 <p fonctionnera aussi bien avec .pml que s’il s’agissait de .html, .php ou .py.>

 946 <espace>

 947 <p De même, un lien>

 948 <code \<a #pagesuivante.pml Suite\>>

 949 <p qui, en html, deviendra>

 950 <code \<a href="pagesuivante.pml"\>Suite\</a\>>

 951 <p sera parfaitement opérationnel.>

 952 <espace>

 953 <p Pour aider à la mise au point des pages, pml.py a été conçu pour pouvoir également être appelé en ligne de commande :>

 954 <p Ainsi la requête navigateur :>

 955 <code localhost/chemin_vers_pml/page37.pml?lang=fr>

 956 <p aura pour équivalent dans un terminal, à partir du répertoire de pml.py :>

 957 <code python[3] pml.py "page37&lang=fr">

 958 <p La page HTML générée (ainsi que les messages d’erreur) s’afficheront bien sûr dans le terminal.>

 959 <p À noter que pml.py dispose d’un système de recouvrement d’erreurs (module <arialb fonctions/trace.py>) qui intercepte les plantages afin de les afficher dans la fenêtre du navigateur. Vous n’avez rien à configurer pour cela.>

 960 <espace>

 961 <p Pour faciliter encore la navigation, un fichier facultatif <arial pml.alias>, situé dans le même répertoire que <arial pml.py>, offre la possibilité de définir des raccourcis (à raison d’un par ligne).>

 962 <p Par exemple, si l’accès standard à une page est>

 963 <code http://www.blary.eu/cultureSF/orion/orion.pml>

 964 <p … si on indique dans <arial pml.alias>>

 965 <code orion.pml = cultureSF/orion/orion.pml>

 966 <p on pourra alors se contenter de :>

 967 <code http://www.blary.eu/orion.pml>

 968 <p … pour obtenir exactement la même navigation.>

 969 <p Attention : ceci n’est évidemment valide que pour des pages pml, et le suffixe ‘.pml’ doit être présent de part et d’autre dans la définition de chaque alias.>

 970

 971 <chapitre 8. Gestion de bases de données MySql ou MariaDB : PyMyAdmin>

 972 #=====================================================================

 973

 974 <p Cet outil, en cours de développement, est conçu comme un quasi-clone de PhpMyAdmin, mais écrit en Python ; utilisant du PML ; plus performant car n’utilisant pas de javascript à outrance ; même si toutes les fonctionnalités de PhpMyAdmin ne seront pas reprises (beaucoup n’étant d’ailleurs que d’une utilité toute relative car d’usage très spécifique et/ou exceptionnel).>

 975 <p.centre <img #<pmlroot>images/pymyadmin225.png>>

 976 <p.centre <rouge (Développement en cours, disponibilité prévue pour la version 0.9)>>


© 2017 Jean-Luc-Blary