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

   1 §tg <span.tgris>

   2

   3 # Note : pour éviter des messages de classes non définies pour celles citées en exemple, un caractère 0x200B (espace de largeur nulle) a été inséré entre « class= » et « "xxxxx" » là où cela se justifiait.

   4

   5 # Emplacement pour le sommaire

   6 <toc>

   7

   8 <chapitre Avertissement>

   9 #=======================

  10 <encadré

  11 ———›<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 afin que le plus grand nombre puisse en profiter.>>

  12 ———›<p <b (courriel : <arial jean-luc[arobase]blary[point]eu>)>>

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

  14 ———›>

  15

  16 <chapitre Préambule>

  17 #===================

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

  19 <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.>

  20 <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.>

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

  22 <espace>

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

  24 <espace>

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

  26 <espace_demi>

  27 <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 :>

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

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

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

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

  32 <p Ces trois modules fonctionnent sous Linux ainsi que sous Windows (testés/vérifiés avec Windows 10.0). Ils fonctionnent probablement aussi sous Mac OS, mais non vérifié.>

  33 <espace_demi>

  34 <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).>

  35 <espace_demi>

  36 <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.)>>

  37 #<espace_demi>

  38 #<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.>

  39 <espace>

  40 <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. >

  41

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

  43 #==================================

  44

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

  46 <pcode \<balise\>texte\</balise\>>

  47 <p par>

  48 <pcode \<balise texte\>>

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

  50 <espace_demi>

  51 <p <u Exemple 1 :>>

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

  53 <pcode \<table\>\<tr\>\<td\>A1\</td\>\<td\>B1\</td\>\</tr\>\<tr\>\<td\>A2\</td\>\<td\>B2\</td\>\</tr\>\</table\>>

  54 <p En PML, il devient :>

  55 <pcode \<table \<tr \<td A1\>\<td B1\>\>\<tr \<td A2\>\<td B2\>\>\>>

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

  57 <espace_demi>

  58 <p <u Exemple 2 :>>

  59 <p Le titre de chapitre « Chapitre I<er> » s’écrit en HTML :>

  60 <pcode \<h1\>Chapitre I\<sup\>er\</sup\>\</h1\>>

  61 <p Grâce aux métabalises (cf. <a ##metabalises chapitre 3. Les métabalises>), il peut devenir en PML :>

  62 <pcode \<chapitre I\<er\>\>>

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

  64 <espace_demi>

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

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

  67 <pcode \<balise[.classe][#id][ #attr1=valeur][ #attr2=valeur] texte\>>

  68 <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).>

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

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

  71 <espace_demi>

  72 <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.>

  73 <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.>

  74 <espace_demi>

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

  76 <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.>

  77 <espace_demi>

  78 <encadré

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

  80 ———›<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.>

  81 ———›<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 !>

  82 ———›>

  83 <espace_demi>

  84 <p <b Remarque :> Les attributs <arial classe> et <arial id> peuvent toujours être codés comme des attributs ordinaires (<arial \<p #class=classe #id=id …\>>). Simplement, les traitements de vérification/optimisation spécifiques à ces attributs ne seront alors pas effectués (par ex. un <arial id> non référencé – donc inutile – ne sera pas signalé).>

  85

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

  87 #====================================================

  88

  89 <sous_chapitre 2.1. Notes aux utilisateurs Windows>

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

  91 <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.)>

  92 <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.)>

  93

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

  95 #---------------------------------------

  96 <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 « & »).>

  97 <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>’.>

  98 <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 « \\ ».>

  99 <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.>

 100 <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.>

 101 <espace_demi>

 102 <p Dans de rares cas, il peut être nécessaire de faire ignorer une séquence qui serait autrement identifiée soit pour contrôle soit pour conversion. Il suffit alors d’y insérer le caractère <arial 0xfffc> (en principe visible comme '<span.sc <span.sc OBJ>>' dans un rectangle). Ce caractère sera simplement supprimé du code HTML final.>

 103

 104 <sous_chapitre 2.3. Règle de base>

 105 #---------------------------------

 106 <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 « \> ».>

 107 <espace_demi>

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

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

 110 <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û.>

 111 <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.>

 112 <espace_demi>

 113 <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 :>

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

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

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

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

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

 119

 120 <sous_chapitre 2.4. Balises longues>

 121 #-----------------------------------

 122 <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.>

 123 <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.>

 124 <espace>

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

 126 <pcode \<table\><br><tg>\<tr\><br><tg><tg>\<td\>A1\</td\><br><tg><tg>\<td\>B1\</td\><br><tg>\</tr\><br><tg>\<tr\><br><tg><tg>\<td\>A2\</td\><br><tg><tg>\<td\>B2\</td\><br><tg>\</tr\><br>\</table\>>

 127 <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 :>

 128 <pcode \<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\>>

 129 <espace>

 130 <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.>

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

 132 <pcode \<table<br><tg>\<tr<br><tg><tg>\<td A1\><br><tg><tg>\<td B1\>\><br><tg>\<tr<br><tg><tg>\<td A2\><br><tg><tg>\<td B2\>\>\>>

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

 134 <p En revanche, si on code :>

 135 <pcode \<table<br>\<tr<br>\<td A1\><br>\<td B1\>\><br>\<tr<br>\<td A2\><br>\<td B2\>\>\>>

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

 137 <pcode \<table /\><br>\<tr /\><br>\<td\>A1\</td\><br>\<td\>B1\</td\>\><br>\<tr /\><br>\<td\>A2\</td\><br>\<td\>B2\</td\>\>\>>

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

 139 <espace>

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

 141 <pcode <tg>\<tr<br><tg><tg>\<td A1\><br><tg><tg>\<td B1\><br><tg><tg>\>>

 142 <p.just0 et non>

 143 <pcode <tg>\<tr<br><tg><tg>\<td A1\><br><tg><tg>\<td B1\><br><tg>\>>

 144 <p.just0 qui donnerait>

 145 <pcode <tg>\<tr\><br><tg><tg>\<td\>A1\</td\><br><tg><tg>\<td\>B1\</td\>\</tr\><br><tg>\>>

 146 <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.>

 147 <espace_demi>

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

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

 150 <espace_demi>

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

 152 <espace>

 153 <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. :>

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

 155 ———›<tg>width:100px;height:100px;margin:auto;text-align:center texte-du-div\>>

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

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

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

 159 <p.just0 tandis que :>

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

 161 ———›<tg>width:100px;height:100px;margin:auto;text-align:center texte-du-div\>>

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

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

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

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

 166

 167 <sous_chapitre 2.5. Texte pur>

 168 #-----------------------------

 169 <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 :>

 170 <pcode (\<script \'''…\'''\>)>

 171 <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.>

 172 <espace_demi>

 173 <encadré

 174 ———›<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 ».>

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

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

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

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

 179 ———›<p.just0 enverra correctement la valeur de la constante.>

 180 ———›>

 181

 182 <sous_chapitre 2.6. Commentaires>

 183 #--------------------------------

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

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

 186 <pcode \#commentaire>

 187 <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).>

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

 189 <pcode \##commentaire>

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

 191 <pcode \<!-- commentaire --\>>

 192 <espace>

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

 194 <pcode \<balise … \<#commentaire\> …\>>

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

 196 <espace>

 197 <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.>

 198 <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.>

 199 <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 «  ».>

 200

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

 202 #-------------------------------------------------------

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

 204 <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). Si la balise a une classe, le forçage doit être avant le point (ex. <arial \<i+.grand !\>>).>

 205 <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.>

 206 <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é. En outre, les <arial id> référencés mais non définis donnent lieu à avertissement (et sont également supprimés).>

 207 <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.>

 208 <espace_demi>

 209 <p <b Note :> Pour un temps de réponse réduit, il est vivement recommandé de limiter au maximum les attributs explicites dans le code PML (#…) et d’en mettre le maximum dans des classes .css plutôt que dans des métabalises. La présence de milliers d’attributs dans une même page peut en effet grever sensiblement le temps de traitement.>

 210

 211 <chapitre#metabalises 3. Les métabalises>

 212 #========================================

 213

 214 <sous_chapitre 3.1. Principe>

 215 #----------------------------

 216 <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 :>

 217 <espace_demi>

 218 <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 :>

 219 <pcode \<pml[ balises.pss[ balises2.pss[…]]]\>>

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

 221 <espace_demi>

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

 223 <pcode \<pml\><br>

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

 225 ———›>

 226 <espace_demi>

 227 <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.>

 228 <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.>

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

 230 <espace>

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

 232 <pcode §balise \<code équivalent\>>

 233 <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).>

 234 <espace_demi>

 235 <p <u Exemple :>>

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

 237 <pcode span.rouge {color:red}<br>span.bleu {color:blue}<br>span.vert {color:red}>

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

 239 <pcode §rouge \<span #class=rouge\>>

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

 241 <pcode \<rouge texte\>>

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

 243 <pcode §rougegras \<rouge #style=text-weight:bold\>>

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

 245 <pcode \<rouge.gras texte\>>

 246 <p qui correspondra en HTML à :>

 247 <pcode \<span class="rouge gras"\>texte\</span\>>

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

 249 <espace>

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

 251 <pcode §rouge \<span #style=color:red\>>

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

 253 <pcode \<span style="color:red"\>texte\</span\>>

 254 <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.>

 255 <espace>

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

 257 <espace>

 258 <p Exemple du chapitre donné dans la présentation générale :>

 259 <pcode §chapitre \<h1 Chapitre\>>

 260 <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.>

 261 <espace_demi>

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

 263 <pcode §partie \<h1.partie \<*\> partie\><br>§re \<sup re\>>

 264 <p.just0 le bref texte>

 265 <pcode \<partie 1\<re\>\>>

 266 <p.just0 sera converti comme>

 267 <pcode \<h1 class=​"partie"\>1\<sup\>re\</sup\> partie\</h1\>>

 268 <espace>

 269 <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.>

 270 <espace_demi>

 271 <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).>

 272 <espace_demi>

 273 <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.>

 274 <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 \<*\>>’.>

 275 <p Attention :>

 276 <p.liste a. Si une espace, insécable ou ordinaire (et plus généralement tout caractère ayant le statut d’espace dans Unicode : fine, demi-largeur, etc.), est déjà présente en fin de texte dans la métabalise, aucune espace supplémentaire n’est ajoutée.>

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

 278 <espace>

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

 280 <pcode \<balise.a+b#c texte\>>

 281 <p.just0 générera>

 282 <pcode \<balise class="a b" id="c"\>texte\</balise\>>

 283 <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\>> »).>

 284

 285 <sous_chapitre 3.2. Les paramètres>

 286 #----------------------------------

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

 288 <pcode §c \<span #style=color:\<*1\>\>>

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

 290 <pcode \<c #red texte\>>

 291 <p.just0 ou>

 292 <pcode \<c ##ff0000 texte\>>

 293 <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é :>

 294 <pcode \<span style="color:#ff0000"\>texte\</span\>>

 295 <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.>

 296 <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 :>

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

 298 <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 ».)>

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

 300 <pcode \<pavé #100 #200 texte\>>

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

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

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

 304 <pcode \<pavé #x=100 #y=200 texte\>>

 305 <espace>

 306 <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.>

 307 <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.>

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

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

 310 <p permet d’écrire :>

 311 <pcode \<pavé #y=200 texte\>>

 312 <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.>

 313 <espace>

 314 <encadré

 315 ———›<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.>

 316 ———›>

 317 <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.>

 318 <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).>

 319 <espace>

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

 321 <espace>

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

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

 324 <pcode \<balise #size=100 texte\>>

 325 <p.just0 donnera>

 326 <pcode \<balise size="100"\>texte\</balise\>>

 327 <espace>

 328 <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.>

 329 <espace>

 330 <encadré

 331 ———›<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.>

 332 ———›>

 333 <espace>

 334 <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 **> ».>

 335 <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é.>

 336 <espace_demi>

 337 <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é.>

 338 <espace_demi>

 339 <p Exemple :>

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

 341 <p Si on écrit ceci :>

 342 <pcode \<image #xxxxx.jpg #h=100px\>>

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

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

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

 346

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

 348 #---------------------------------------------------

 349 <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.>

 350 <p Par exemple :>

 351 <pcode §question \<p — \<*\> ?\><br>§guil \<§ « \<*\> »\>>

 352 <p.just0 remplaceront :>

 353 <pcode \<question Vous avez dit \<guil Bizarre\>\>>

 354 <p.just0 par :>

 355 <pcode \<p\>— Vous avez dit « Bizarre » ?\</p\>>

 356 <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 :>

 357 <pcode §guil \<§ “\<*\>”\>\>>

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

 359 <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.>

 360 <espace>

 361 <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.>

 362 <espace_demi>

 363 <p <u Exemple :>>

 364 <pcode §identifiant \<§ \<h1 <insécable>\><br>

 365 ———›<tg><tg>\<div #style=align:center<br>

 366 ———›<tg><tg><tg>\<p.centre ISBN \<*1\>\><br>

 367 ———›<tg><tg><tg>\<p.centre © \<*2\> Éditions maison\><br>

 368 ———›<tg><tg><tg>\>\>>

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

 370 <pcode \<identifiant #978-2-7544-2017-6 #2017\>>

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

 372 <pcode \<h1\><insécable>\</h1\><br>

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

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

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

 376 ———›<tg>\</div\>>

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

 378 <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.>

 379 <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).>

 380

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

 382 #==============================================================

 383

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

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

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

 387

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

 389 #--------------------------------------------------------------------

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

 391 <pcode \<img[.classe][#id] #lien [ #attributs=…] [texte]\>>

 392 <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).>

 393 <espace_demi>

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

 395 <pcode \<a[.classe][#id] #lien [ #attributs=…] [texte]\>>

 396 <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.>

 397 <espace_demi>

 398 <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 :>

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

 400 <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).>

 401 <espace_demi>

 402 <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.>

 403 <espace_demi>

 404 <encadré

 405 ———›<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.>

 406 ———›<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é – comme par exemple <arial \<*num\>>.>

 407 ———›>

 408 <espace_demi>

 409 <p Pour les balises <arialb input>, <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.>

 410 <espace_demi>

 411 <p <u Exemple :>>

 412 <pcode \<input #type=text #name=c_objet #maxlength=64 #size=40 \<%c_objet\>\>>

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

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

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

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

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

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

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

 420

 421 <sous_chapitre 4.2. SVG>

 422 #-----------------------

 423 <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.>

 424 <p Exemple :>

 425 <pcode <tg>\<svg_1<br>

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

 427 ———›<tg><tg>\>>

 428

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

 430 #-------------------------------------------------------

 431 <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 :>

 432 <pcode \<smallcaps texte\>>

 433 <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).>

 434 <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 ».>

 435

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

 437 #--------------------------------------

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

 439 <pcode \<note texte\>>

 440 <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 ».>

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

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

 443 <pcode §note \<note #parent=h1 #format=[1] #début=1 #init=h1 #classeref=note<br><tg>#classetxt=txtnote\>>

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

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

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

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

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

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

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

 451 <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 :>

 452 <pcode §note \<note #format=(i) #init=body\>>

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

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

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

 456 <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>…)>

 457 <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>…)>

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

 459 <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.>

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

 461 <p Pour <arial parent> et <arial init>, pas de contrôle des noms donnés : un nom invalide sera comme une balise absente du document. Par ailleurs, la balise définie avec 'init' aura le même effet de rupture que la balise 'parent'.>

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

 463 <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.>

 464 <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. :>

 465 <pcode §notefin \<note #parent=body #format=[i] #init=body #classeref=note<br><tg>#classetxt=txtnotefin\>>

 466 <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.>

 467 <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.>

 468

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

 470 #----------------------------------------------------

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

 472 <espace_demi>

 473 <p <u Exemple :>>

 474 <pcode \<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.\>>

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

 476 <pcode \<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\>>

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

 478 <pcode \<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\>>

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

 480 <pcode 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.>

 481 <p et>

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

 483 <espace_demi>

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

 485

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

 487 #--------------------------------------

 488 <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 :>

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

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

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

 492 <p.liste – <arial .sommaire> : le style css du titre du sommaire (par défaut, le style normal de <arial h1>). Naturellement, le style peut s’appeler autrement que « sommaire ».>

 493 <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). Jusqu’à cinq niveaux sont possibles.>

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

 495 <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.>

 496 <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é.>

 497 <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.>

 498 <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.>

 499 <espace_demi>

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

 501 <pcode §partie \<h1 \<*\> partie\><br>

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

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

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

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

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

 507 <p Jusqu’à 5 niveaux sont possibles.>

 508 <espace_demi>

 509 <encadré

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

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

 512 ———›<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.>

 513 ———›<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.>

 514 ———›<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à.>

 515 ———›>

 516 <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.>

 517

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

 519 #-------------------------------------------

 520 <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 …\>>.>

 521 <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).>

 522 <espace_demi>

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

 524 <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 ;>

 525 <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é ;>

 526 <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 …\>>).>

 527 <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 – ce qui l’accompagnerait sur la même ligne disparaîtra de la conversion.>

 528

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

 530 #======================================

 531

 532 <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.>

 533

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

 535 #-----------------------------------------------------

 536 <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.>

 537 <pcode \<import fichier.pml\>>

 538 <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.>

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

 540 <p <u Attention :> un import ne peut être conditionné par une constante, un retour d’appel Python ou une balise conditionnelle : si une telle condition est nécessaire, elle doit être définie dans le fichier importé.>

 541 <espace_demi>

 542 <encadré

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

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

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

 546 ———›>

 547

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

 549 #-------------------------------------

 550 <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.>

 551 <pcode \<py fonction(paramètres…)\>>

 552 <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>).>

 553 <espace_demi>

 554 <p <b <u Attention :>>>

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

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

 557 <espace_demi>

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

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

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

 561 <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.>

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

 563 <espace_demi>

 564 <encadré

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

 566 ———›<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.>

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

 568 ———›<p Note : Si la métabalise <arial \<py …\>> n’est pas indentée, il en sera évidemment de même pour chaque élément, qui doit alors contenir une balise complète, sans suite dans l’élément suivant.>

 569 ———›>

 570

 571 <sous_chapitre#constantes 5.3. Constantes : \<%xxx\>>

 572 #----------------------------------------------------

 573 <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é.>

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

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

 576 <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>.>

 577 <p – <arial \<dir\>> : selon la langue définie, contient le sens d’écriture sous la forme <arial ltr> (gauche à droite) ou <arial rtl> (droite à gauche : arabe, hébreu…) Permet de prendre en compte l’écriture dans la mise en page (exemple plus bas, dans <a ##multilangue 5.7 Multilinguisme>).>

 578 <espace>

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

 580 <pcode §%isbn \<978-2-7544-2017-6\>>

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

 582 <pcode \<%isbn\>>

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

 584 <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>.>

 585 <espace_demi>

 586 <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.>

 587 <espace_demi>

 588 <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».>

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

 590 <espace_demi>

 591 <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.>

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

 593 <espace>

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

 595 <pcode §%isbn \<\<py isbn('\<document\>')\>\>>

 596 <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.>

 597 <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 !>

 598 <p <u Attention :> <arial \<py …\>> est la seule balise autorisée à l’intérieur d’une constante – en sus des balises de formatage simple comme <arial 'i', 'b', 'u', 'sup', 'sub'> !>

 599 <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.>

 600 <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[ …]]>>

 601 <espace_demi>

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

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

 604 <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).>

 605 <p.liste – créée directement (sans déclaration préalable) lors d’un appel de routine Python, en l’ajoutant à la liste <arial 'pydata'> : on peut alors utiliser au choix <arial \<%pydata.xxx\>> ou <arial \<%%xxx\>> (si on a assigné <arial pydata['xxx']>)>

 606 <espace_demi>

 607 <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.>

 608 <espace_demi>

 609 <encadré

 610 ———›<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\>> !>

 611 ———›>

 612 <espace_demi>

 613 <encadré

 614 ———›<p <u <b Autre astuce :>> On pourrait définir une constante comme métabalise, mais le comportement n’est pas nécessairement identique. En effet :>

 615 ———›<pcode §co2 \<§ CO\<sub 2\>\>>

 616 ———›<p … qui définit la métabalise <arial \<co2\>> et>

 617 ———›<pcode §%co2 \<CO\<sub 2\>\>>

 618 ———›<p … qui définit la constante <arial \<%co2\>>, auront toutes deux comme remplacement dans le texte la valeur <arial CO<sub 2>>, mais la première sera toujours suivie d’une espace, contrairement à la seconde !>

 619 ———›>

 620

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

 622 #---------------------------------------------------

 623 <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). (cf. <a ##locales Les fichiers de littéraux et messages>))>

 624 <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.>

 625 <p Un littéral étant une métabalise à part entière, sauf qu’elle est générée depuis le contenu du répertoire <arial locales>, le texte d’un littéral peut contenir des paramètres et/ou un texte associé tels que définis au chapitre 3.>

 626 <espace_demi>

 627 <p <u Exemple :>>

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

 629 <pcode \<@test pml\>>

 630 <p donnera respectivement :>

 631 <pcode C’est pml qu’on teste.<br>

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

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

 634 <espace>

 635 <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.>

 636 <espace_demi>

 637 <p <u Exemple :>>

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

 639 <pcode \<@countdown #2 #59\>>

 640 <p.just0 donnera :>

 641 <pcode Il vous reste 2 minutes et 59 secondes.>

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

 643 <pcode \<@countdown #s=59 #mn=2\>>

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

 645 <espace_demi>

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

 647 <espace_demi>

 648 <p <u Note 2 :> Le caractère initial <arial @> étant un identifiant de littéral, la définition de métabalises commençant par ce caractère est interdite.>

 649 <espace_demi>

 650 <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.>

 651

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

 653 #------------------------------------------------------------------------------

 654 <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).>

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

 656 <espace_demi>

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

 658 <pcode \<incl %param=valeur[ %param=valeur …] \<balise …\>\>>

 659 <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.>

 660 <p <arial \<excl> fera l’inverse : la balise sera présente sauf si le ou les paramètres possèdent tous la valeur indiquée.>

 661 <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 :>

 662 <pcode \<incl %param \<balise …\>\>>

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

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

 665 <pcode \<excl %param …\><br>

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

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

 668 <pcode \<incl %param1 %param2- …\>>

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

 670 <espace>

 671 <p 2. Délimitation :>

 672 <pcode \<incl %param=valeur[ %param=valeur …]\><br>

 673 ———›<br>

 674 ———›\<incl\>>

 675 <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.>

 676 <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).>

 677 <espace>

 678 <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'.>

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

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

 681 <pcode<br>

 682 ———›\<titre _principal Titre de livre\><br>

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

 684 ———›<br>

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

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

 687 ———›>

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

 689 <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>.>

 690 <espace>

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

 692 <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).>

 693 <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.>

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

 695 <p Exemple :>

 696 <pcode \<incl %src=abc\><br>

 697 ———›<br>

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

 699 ———›<br>

 700 ———›\<else\><br>

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

 702 ———›\<incl\>>

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

 704 <espace>

 705 <p Il est également possible, pour les comparaisons '=' et '≃', de spécifier une liste de valeurs : la comparaison sera validée dès que l’une des valeurs correspondra. Pour ce faire, les valeurs doivent être séparées par des virgules, et le tout mis entre parenthèses.>

 706 <p Exemple :>

 707 <pcode \<incl lang<span.extra>(fr,en,de)\>>

 708 <p.just0 inclura ce qui suit cette condition dès lors que la langue sera du français, de l’anglais ou de l’allemand, ou une de leurs variantes.>

 709 <p <u Attention :> n’est pas accepté pour '≠', vu qu’avec plusieurs valeurs la constante sera forcément différente de toutes sauf une !>

 710 <espace>

 711 <encadré

 712 ———›<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.>

 713 ———›<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.>

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

 715 ———›>

 716

 717 <sous_chapitre 5.6. Directives HTTP \<http …\>>

 718 #----------------------------------------------

 719 <p Cette balise permet de définir des directives <arial 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).>

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

 721 <espace_demi>

 722 <p <u Exemple :>>

 723 <pcode \<pml\><br>

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

 725 ———›\<incl %ok!=oui \<http Location: http://pml.blary.eu/\>\><br>

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

 727 <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.>

 728 <espace>

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

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

 731 <espace_demi>

 732 <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.>

 733

 734 <sous_chapitre#multilangue 5.7. Multilinguisme \<@ \<@.lg1 …\>\<@lg2 …\>…>

 735 #-------------------------------------------------------------

 736 <p Bien que d’une utilité réduite dans le cas de création d’ePub, le multilinguisme peut avoir une grande importance dans le cas de sites Internet.>

 737 <p L’environnement PML facilite au maximum sa prise en compte :>

 738 <coché Grâce au répertoire <arial locale> et à son contenu entièrement configurable pour tous les termes et expressions qu’on désire dans autant de langues qu’on souhaite : il suffit alors dans le source pml d’utiliser le littéral idoine et tout est pris en compte automatiquement.>

 739 <coché Grâce à la constante <arial \<lang\>> qui indique la langue ou variante en cours et permet de conditionner des affichages.>

 740 <coché Grâce à la constante <arial \<dir\>> qui contient le sens d’écriture et permet de conditionner des styles à celui-ci.>

 741 <p Exemple :>

 742 <pcode .gauche, .gaucheltr { text-align:left;}<br>

 743 ———›.gauchertl { text-align:right;}>

 744 <p.just0 dans la feuille de style .css, et :>

 745 <pcode \<p.gauche texte toujours à gauche\><br>

 746 ———›\<p.gauche\<dir\> texte aligné selon langue de référence\>>

 747 <p.just0 le second paragraphe bénéficiera automatiquement du bon alignement selon la langue (à gauche en français, à droite en arabe, etc.)>

 748 <espace_demi>

 749 <coché Enfin, grâce à la balise <arial \<@ …\>> qui regroupe diverses traductions d’un même texte et sélectionne automatiquement celui de la langue courante.>

 750 <p Exemple ci-dessous :>

 751 ———›#<tg><tg>\<@.ar <span.extra ما هي هذه الفوضى؟>\><br>

 752 ———›#<tg><tg>\<@.he <span.extra מה זה הבלגן הזה>?>\><br>

 753 <pcode

 754 ———›\<pml\><br>

 755 ———›\<p \<@<br>

 756 ———›<tg><tg>\<@.fr C’est quoi ce bordel ?\><br>

 757 ———›<tg><tg>\<@.fr-BE C’est quoi ce brol ?\><br>

 758 ———›<tg><tg>\<@.ca+es Què és aquest embolic?\><br>

 759 ———›<tg><tg>\<@.ar <span.extra ما هي هذه الفوضى؟>\><br>

 760 ———›<tg><tg>\<@.he <span.extra מה זה הבלגן הזה>?\><br>

 761 ———›<tg><tg>\<@.en What’s the fuck?\><br>

 762 ———›<tg><tg>\>\>

 763 ———›>

 764 <p L’affichage pourra être :>

 765 <p – en français ou toute variante du français (fr-CA, fr-CH…) sauf le belge ;>

 766 <p – en belge francophone ;>

 767 <p – en catalan ou espagnol ou toute variante de l‘une de ces langues (oui, la phrase est en catalan, pas en castillan, mais c’est juste à titre d’exemple…) ;>

 768 <p – en arabe ou toute variante de l’arabe (et automatiquement définie de droite à gauche) ;>

 769 <p – en hébreu (de droite à gauche également) ;>

 770 <p – enfin, en anglais dans tous les autres cas !>

 771 <p Et tout ça sans devoir écrire une ligne de code ! (L’exemple ci-dessus n’a même pas besoin de feuille de style .css.) Il suffit juste de faire les bons descriptifs en PML… Les possibilités ne sont limitées que par votre imagination !>

 772 <espace_demi>

 773 <p Un exemple est visible avec la page <a #http://pml.blary.eu/>, disponible en trois langues.>

 774

 775 <sous_chapitre 5.8. Mises à jour et affichages temporaires ou périodiques>

 776 #-------------------------------------------------------------------------

 777 <p <i <rouge (à venir)>>>

 778

 779 <chapitre 6. Les outils>

 780 #=======================

 781

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

 783 <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).>

 784 <p.liste <u Contenu :>>

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

 786 <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…>

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

 788 <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.>

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

 790 <espace_demi>

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

 792 <p.liste <u Contenu :>>

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

 794 <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)>

 795 <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)>

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

 797 <p.liste2 – Un fichier <arial .htaccess> avec les instructions permettant à Apache de reconnaître et traiter des documents PML.>

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

 799 <p.liste2 – Les fichiers <arial 403.pml> appelé quand la page demandée existe mais n’est pas autorisée – et <arial 500.pml> appelé quand un problème est survenu sur le serveur. Ils sont également personnalisables.>

 800 <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://pml.blary.eu>.)>

 801 <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…)>

 802 <espace_demi>

 803 <p.liste C. La présente documentation sous forme d’ePub.>

 804 <espace_demi>

 805 <p.liste D. Un pack <b pymyadmin> contenant un remplaçant de <b phpmyadmin> pour la plupart des fonctionnalités utiles, avec quelques ajouts qui l’enrichissent par ailleurs. En cours de développement, seules quelques fonctionnalités basiques sont disponibles. Cf. <a ##pymyadmin 8. Gestion de bases de données MySql ou MariaDB : PyMyAdmin>.>

 806 <espace>

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

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

 809 <p.liste – Python 3.8 ou supérieur, téléchargeable sur <a #https://www.python.org/downloads/windows/>.>

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

 811 <p.liste – Ainsi que quelques greffons Python, précisés plus bas.>

 812 <encadré

 813 ———›<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>.>

 814 ———›<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.)>

 815 ———›>

 816

 817 <sous_chapitre 6.1. Installation>

 818 #--------------------------------

 819 <p.just0 <flèche> <b Windows (W7 minimum) :>>

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

 821 <p Installer <arial win-unicode-console> avec <arial pip install win-unicode-console>.>

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

 823 <espace_demi>

 824 <p.just0 <flèche> <b Linux :>>

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

 826 <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).>

 827 <espace_demi>

 828 <p.just0 <flèche> <b Tous systèmes :>>

 829 <p Les modules python suivants sont nécessaires et devront être installés :>

 830 <p <arialb polib>, indispensable pour la gestion des littéraux et des messages ; <arialb PIL>, indispensable pour htmlepub (attention, prendre <arial python-pil> pour python3 – et non <arial pillow> python2, non compatible) ; et <arialb fonttools>, également indispensable pour htmlepub. Ces greffons s’installent avec <arial pip install …>.>

 831 <p Si besoin est, <arialb mysql.connector> : pour toute fonction utilisateur devant accéder à une base de données. N’est importé que depuis le module utilisateur <arial modules.py>, à ôter ou mettre en commentaire si aucune BdD n’est utilisée. Vérifier également en ce cas qu’il n’y a pas de fichiers <arial config.conf> (qui définit les accès BdD) dans le répertoire défini par <arial %scripts> (dans <arial pml.cfg>).>

 832 <espace_demi>

 833 <p.just0 <flèche> <b Serveur internet :>>

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

 835 <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.>

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

 837

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

 839 #-------------------------------------------------------

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

 841 <pcode code = valeur>

 842 <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).>

 843

 844 <sous_chapitre#locales 6.3 Les fichiers de littéraux et messages>

 845 #--------------------------------------------------------

 846 <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 <arial locale>, ils doivent s’intituler msg_xx.mo (pour les messages) et pml_xx.mo pour les littéraux utilisateur (pyma_xx.mo pour l’environnement PyMyAdmin).>

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

 848 <p À noter qu’un fichier <arial languages.ref> liste les 374 langues et variantes reconnues selon le code ISO 639-1.>

 849 <p Également, lors de la génération des fichiers .mo, un récapitulatif <arial locales.ref> liste les langues et variantes disposant de traductions avec leur taux de couverture. Cela permet, le cas échéant, de ne proposer à l’utilisateur/visiteur que les langues pertinentes (ce qui est d’ailleurs fait dans <arial pymyadmin>).>

 850

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

 852 #---------------------------------------------

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

 854 <pcode python[3] [chemin/]pmlimport.py [-feuille.pss] [document.html|document.epub] [-o fichier[.pml]][ -ignore classe1[,classe2…]] [ -indent] [re<i attribut> <i propriété>:0|pas[,<i propriété>:0:pas]…]>

 855 <espace_demi>

 856 <p<arial -feuille.pss>’ est une option de spécification d’une feuille de style .pss (remplacez 'feuille' par le nom du fichier) à 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).>

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

 858 <espace_demi>

 859 <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.>

 860 <pcode ignore calibre4,i.calibre6>

 861 <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é.>

 862 <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). De même, le ‘*’ remplace n’importe quelle suite de caractères : <arial -ignore calibre*> ignorera toutes les classes dont le nom commence par ‘calibre’.>

 863 <espace_demi>

 864 <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 donc souvent presque illisible), car apportant la lisibilité nécessaire à la compréhension.>

 865 <espace_demi>

 866 <p <arial -re<i attribut>> arrondit ou ignore des attributs et/ou propriétés spécifiées directement dans le source HTML, permettant de simplifier le code converti. Si la valeur de <arial <i propriété>> est 0, celle-ci est ignorée, sinon sa valeur est arrondie à la valeur la plus proche d’un multiple du pas indiqué. En général, l’attribut concerné est <arial style>, d’où paramètre <arial -restyle>. Plusieurs propriétés peuvent être spécifiées.>

 867 <p Pour les propriétés ayant des unités, conversion est faite en fonction des ratios : si l’arrondi demandé est en mm, les valeurs en cm seront arrondies au dixième, etc. Les correspondances prises sont : <arialb 'px':96, 'pt':72, 'mm':25.4, 'ch':12, 'pc':6, 'em':6, 'cm':2.54, 'in':1>. Si aucune unité n’est fournie, c’est 'px' qui est pris. Les pas sont forcés à des valeurs entières pour les pixels ou les points, des fractions proches équivalentes pour les autres unités – inutile donc de mettre des pas trop faibles ou avec plusieurs chiffres.>

 868 <p <u Exemple :> <arial -restyle font-size:12,letter-spacing:0,background-color:0,bgcolor:0,clip:0,margin-left:0,margin-right:0,margin-top:0,margin-bottom:0,margin:0,text-indent:0,line-height:0,font-family:0,top:0,left:0> arrondira toutes les propriétés font-size 'en dur' à un multiple de 12px ou équivalent dans une autre unité, et supprimera les autres (dans le cas présent, il s’agit généralement de valeurs provenant de documents Word ou LO issus de numérisation, où beaucoup de valeurs calculées par l’OCR sont sans cohérence aucune, et ce paramètre fournit un pré-nettoyage appréciable).>

 869 <espace>

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

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

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

 873 <p est convertie comme suit :>

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

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

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

 877 <pcode \<balise_abc_n texte\>>

 878 <p <u Remarques :>>

 879 <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]'.>

 880 <p.liste – Si une définition identique 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.>

 881 <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é.>

 882 <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. Il en est de même avec les polices de caractères incorporées.>

 883 <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.>

 884 <p.liste – En cas de message d’erreur signalant que la couverture n’a pas été trouvée, cela signifie presque toujours que ladite couverture est quand même bien présente, mais n’a pas été correctement définie dans les métadonnées.>

 885 <espace>

 886 <encadré

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

 888 ———›<coché Si, comme souvent, une même balise avec les mêmes attributs et les mêmes valeurs (d’origine ou arrondie avec le paramètre <arial -re…>) apparaît 36 fois dans le document HTML (ce qui est toujours le cas dans les conversions Word→HTML et très fréquent également dans les exports odt→HTML), une seule redéfinition est faite, ce qui :>

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

 890 ———›<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.>

 891 ———›<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.>

 892 ———›<coché En cas de conversion d’un document HTML ancien, les attributs dépréciés sont, dans la mesure du possible, remplacés par leurs équivalents HTML5.>

 893 ———›>

 894

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

 896 #---------------------------------------------

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

 898 <pcode python[3] [chemin/]pmlexport.py document.pml [-o fichier[.html]] [-epub|-epub2|epub3] [-cover chemin/image.fmt] [%constante=valeur]…>

 899 <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).>

 900 <p Les paramètres destinés à <arial htmlepub> peuvent également être spécifiés à l’appel de <arial pmlexport>, ils sont simplement transmis au générateur d’ePub.>

 901 <espace_demi>

 902 <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.>

 903 <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>.>

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

 905 <espace>

 906 <encadré

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

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

 909 ———›<coché Les balises ou métabalises invalides apparaissent comme texte mis en valeur « <arial.rouge+fondjaune \<balise?\>> » (avec également message d’erreur) tout en étant remplacées par un <arial \<span…\>>, et sont donc immédiatement repérées et rectifiables.>

 910 ———›<coché Les classes utilisées sont vérifiées : si l’une d’elles n’est définie nulle part, un message d’avertissement est émis.>

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

 912 ———›<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.>

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

 914 ———›<coché Nettoyage du code par suppression des balises de type <arial span> (<arial b>, <arial i>, <arial sup>, <arial sub>, 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.>

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

 916 ———›<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.>

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

 918 ———›<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.>

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

 920 ———›>

 921

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

 923 #--------------------------------------------

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

 925 <pcode python[3] [chemin/]htmlepub.py document.html [-epub3] [-oebps xxx] [-cover chemin/image.fmt]>

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

 927 <p<arial -oebps>’ permet de forcer le nom du répertoire interne de l’epub contenant les fichiers xhtml. Par défaut, sa valeur est <arial 'oebps'> ou celle spécifiée dans 'pml.cfg'.>

 928 <p<arial -cover>’ permet de forcer l’usage d’une image de couverture spécifique, indépendamment de la configuration pour les couvertures « standard ».>

 929 <espace>

 930 <encadré

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

 932 ———›<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.>

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

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

 935 ———›<coché Identifie tous les caractères utilisés afin de filtrer les fichiers de polices et les réduire à ce qui est réellement utile (peut réduire certains fichiers jusqu’à 1 % de la taille originale !). Et bien sûr n’incorpore que les polices effectivement utilisées !>

 936 ———›<coché Si un style mentionne plusieurs familles de polices, les caractères éventuellement manquants dans la première seront définis pour la deuxième, etc. Chaque police filtrée donne lieu à un message indiquant le nombre de caractères pris en compte – et éventuellement ceux qui n’auraient pas été trouvés, ce qui sous-entend de revoir le code soit en changeant le ou les caractères, soit en les affectant spécifiquement à une police les contenant.>

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

 938 ———›>

 939 <espace_demi>

 940 <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>.>

 941 <p Ex :>

 942 <pcode \<meta name="type" content="Science-fiction" /\><br>

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

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

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

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

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

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

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

 950 <pcode \<meta #name=type #content=Science-fiction\><br>

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

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

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

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

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

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

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

 958 <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.>

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

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

 961 <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) :>

 962 <pcode \<meta name="creator" opf:role="xyz" … /\><br>

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

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

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

 966 <encadré

 967 ———›<p <u Note :> Cet outil ne prend pas en compte les balises <arial style> ni <arial script> : pour un ePub, tout doit être défini dans des fichiers .css ou .js. Si on génère un ePub directement à partir de <arial pmlexport> (avec l’option -epub), les balises en question sont signalées comme invalides et non intégrées dans le document HTML intermédiaire.>

 968 ———›>

 969

 970 <sous_chapitre 6.7. L’utilitaire font2sc.py>

 971 #-------------------------------------------

 972 <p Pour créer une police de caractères où les minuscules sont remplacées par des petites capitales.>

 973 <pcode python[3] [chemin/]font2sc.py [répertoire polices/]police.[ttf|otf]>

 974 <p Crée un fichier police_sc.[ttf|otf] dans le même répertoire que la police source.>

 975 <espace_demi>

 976 <p Crée également un ePub "police.epub" listant les caractères concernés, avec comparaison majuscules/minuscules/capitales réduites/petites capitales.>

 977 <p Dans cet ePub, les couleurs indiquent l’état de conversion pour chaque caractère :>

 978 <p • Noir : caractère correctement traité (caractère simple ou composé d’une simple suite de caractères).>

 979 <p • Violet : caractère composé (notamment accentué), correctement traité pour la plupart, quelques cas particuliers restant à prendre en compte.>

 980 <p • Bleu : caractère complexe, non traité actuellement.>

 981 <p Tous les caractères courants en Europe Occidentale sont correctement traités, seuls restent non corrects des cas complexes genre accents multiples, notamment sur les alphabets non latins. La conversion de tous les cas est prévue pour la prochaine version (en principe 10.1, courant 2021).>

 982 <encadré

 983 ———›<p <u Important :> Cet outil ne se contente pas de remplacer les minuscules par des capitales réduites, il crée réellement des petites capitales, avec accents non réduits et un rapport largeur/hauteur plus important. L’épaisseur globale du trait n’est pas encore parfaite, mais les caractères créés donnent un résultat sensiblement plus agréable à l’œil que des majuscules réduites.>

 984 ———›>

 985 <espace_demi>

 986 <p Ces polices « smallcaps » – famille spécifique distincte de l’original – sont à définir dans les feuilles de style comme toute police à charger/incorporer, leur usage est indépendant de PML.>

 987 <p Leur énorme avantage est que pour définir un bout de texte en petites capitales, il suffit de mettre celui-ci – écrit normalement avec majuscules, minuscules et ponctuation – à l’intérieur d’une balise "span" avec le style faisant appel à la bonne police.>

 988 <encadré

 989 ———›<p <u Note :> Curieusement, ces polices générées, si elles fonctionnent parfaitement pour un ePub et s’affichent correctement dans les outils tels que Fontforge, n’affichent pas toujours correctement certains caractères dans le navigateur ou dans un texteur (ex. accent resté à la hauteur de la majuscule…). Aucune explication trouvée actuellement, mais comme ça ne se produit que pour des caractères non « Europe Occidentale », ça reste véniel.>

 990 ———›>

 991

 992 <sous_chapitre 6.8. Routines Python utiles>

 993 #------------------------------------------

 994 <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.>>

 995 <h3 Fonctions de trace>

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

 997 <p.liste 1. <arialb trace.log> fonctionne comme un <arial print>.>

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

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

1000 <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.>

1001 <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 avec un indice lui-même variable, genre <arial tab[xt]>.>

1002 <espace_demi>

1003 <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 à un horodatage et au fichier avec l’arborescence des appels de fonctions avec le numéro de la ligne où elles ont été appelées. Il est ainsi facile de vérifier où et quand on avait ces valeurs.>

1004 <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.>

1005

1006 <h3 Tri naturel>

1007 <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.>

1008 <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.>

1009 <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).>

1010 <espace_demi>

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

1012 <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>.>

1013 <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 (probablement) pas été bien comprise.>

1014 <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).>

1015 <espace_demi>

1016 <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.>

1017 <espace_demi>

1018 <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 !>

1019

1020 <h3 Génération de code PML>

1021 <p Destinée aux routines Python, cette fonction permet de sécuriser la syntaxe du PML : les erreurs d’indentation PML deviennent des erreurs d’imbrication/syntaxe Python, donc détectées plus rapidement.>

1022 <p Format général :>

1023 <pcode PML(balise[,texte[,paramètres positionnels][,paramètres nommés]])>

1024 <p Exemples :>

1025 <pcode PML('espace')<br>

1026 ———›PML('p.gauche','Baratin')<br>

1027 ———›PML('td','Baratin',style="vertical-align:top")<br>

1028 ———›PML('a.neutre', PML('div.gauche', PML('span.nobr+t10', PML('b', PML('img', '', tbl_icon['BASE'])+' '+_base)),<br>

1029 ———›<tg><tg><tg><tg><tg><tg><tg><tg><tg>id_='xbase{0}'.format(imenu)),<br>

1030 ———›<tg><tg><tg><tg>'#',onclick="showbases(\\\\\'{0}\\\\\',\\\\\'{1}\\\\\',\\\\\'{2}\\\\\',\\\\\'{3}\\\\\')".format(imenu,nmenu,tbl_icon['BASE'],_base), style="cursor:pointer")>

1031 <p.just0 génèrent :>

1032 <pcode \<espace\><br>

1033 ———›\<p.gauche Baratin\><br>

1034 ———›\<td #style=vertical-align:top Baratin\><br>

1035 ———›\<a.neutre ## #onclick=showbases('1','8','themes/original/img/s_db.png','bibliotheque') #style=cursor:pointer \<div.gauche #id=xbase1 \<span.nobr+t10 \<b \<img #themes/original/img/s_db.png\> bibliotheque\>\>\>\>\>>

1036 <p La seule différence dans l’ordonnancement est que le texte vient en deuxième position au lieu d’être à la fin. Les paramètres nommés susceptibles d’interférer avec des mots-clés Python doivent être suffixés avec '_' (ex : <arial class_> ou <arial id_>).>

1037

1038 <h3 Prétraitement avec userconfig>

1039 <p Il est possible de définir dans <arial modules> une fonction nommée <arial userconfig>. Celle-ci ne reçoit pas de paramètres mais, appelée après le chargement des données de configuration et avant le début du vrai traitement du source PML, elle peut prendre en compte des paramètres en entrée afin de lire/modifier/enregistrer des valeurs personnalisées (ex. utilisation d’un thème personnalisé).>

1040 <p Pour un exemple, voir dans <arial fonctions/modules> de <arial PymyAdmin> comment sont mémorisés langue et thème de l’utilisateur.>

1041

1042 <chapitre 7. L’utilitaire pml>

1043 #=============================

1044

1045 <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.>

1046 <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.>

1047 <espace>

1048 <encadré

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

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

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

1052 ———›<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 carrément de créer des sites complets.>

1053 ———›>

1054 <espace>

1055 <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 4 pages en pml : <arial index.pml>, <arial 403.pml>, <arial 404.pml> et <arial 500.pml>. La première permet de tester le bon fonctionnement en saisissant dans la barre d’adresse du navigateur :>

1056 <pcode http://chemin_vers_pml/index.pml>

1057 <p ou, en local :>

1058 <pcode localhost/chemin_vers_pml/index.pml>

1059 <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>.>

1060 <p <arial 403.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> existe mais est à accès restreint, donc en l’occurrence non autorisée.>

1061 <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.>

1062 <p <arial 500.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 le serveur ne parvient pas à générer <arial xyz.pml> suite à une erreur dans le processus.>

1063 <espace>

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

1065 <pcode localhost/chemin_vers_pml/rep1/rep2/pagerep3.pml>

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

1067 <espace>

1068 <p De même, un lien>

1069 <pcode \<a #pagesuivante.pml Suite\>>

1070 <p qui, en html, deviendra>

1071 <pcode \<a href="pagesuivante.pml"\>Suite\</a\>>

1072 <p sera parfaitement opérationnel.>

1073 <espace>

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

1075 <p Ainsi la requête navigateur :>

1076 <pcode localhost/chemin_vers_pml/page37.pml?lang=fr>

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

1078 <pcode python[3] pml.py "page37&lang=fr">

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

1080 <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.>

1081

1082 <sous_chapitre 7.1. Les alias>

1083 #-----------------------------

1084

1085 <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).>

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

1087 <pcode http://www.blary.eu/cultureSF/orion/orion.pml>

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

1089 <pcode orion.pml = cultureSF/orion/orion.pml>

1090 <p on pourra alors se contenter de :>

1091 <pcode http://www.blary.eu/orion.pml>

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

1093 <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.>

1094

1095 <sous_chapitre 7.2. Mise en cache>

1096 #---------------------------------

1097

1098 <p Pour les pages relativement statiques, il est possible de spécifier qu’elles peuvent être mises en cache, de sorte que le serveur récupère directement le format HTML sans le recréer à chaque fois, d’où un gain en performances.>

1099 <p Pour ce faire, il suffit d’ajouter dans la ligne initiale le paramètre <arial \#cache> : Exemple : <arial \<pml \#cache\>>.>

1100 <p Ce paramètre peut précéder ou suivre les éventuelles spécifications de fichiers de métabalises.>

1101 <p <u Important :> Un cache est généré pour chaque groupe de valeurs des paramètres fournis (on peut donc par exemple avoir un fichier généré mis en cache pour chaque langue utilisée). C’est pourquoi il faut s’en tenir aux pages statiques.>

1102 <p Si une page est modifiée, il suffit d’effacer son cache (dans le répertoire du même nom).>

1103 <p Depuis la version 0.10, il est possible (et même recommandé) de donner la liste des paramètres valides : <arial \<pml \#cache=param1,param2[,…]\>>. Ainsi, ceux qui seraient transmis sans y figurer (souvent des tentatives de hackage) sont ignorés et ne génèrent pas d’item supplémentaire dans le cache. Si aucun paramètre n’est spécifié pour le cache, c’est qu’il ne doit pas y en avoir et la page mise en cache reste unique.>

1104

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

1106 #===============================================================================

1107

1108 <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).>

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

1110 <p.centre <rouge (Développement en cours, disponibilité de l’essentiel des fonctionnalités prévue pour une prochaine version)>>

1111

1112 <sous_chapitre 8.1. État du développement>

1113 #-----------------------------------------

1114

1115 <p Le pack PyMyAdmin proposé, pour le moment encore une ébauche, dispose des fonctions suivantes :>

1116 <p.liste – Une page d’identification pleinement fonctionnelle, avec choix de langue, nécessitant code utilisateur et mot de passe MySql/MariaDB valide.>

1117 <p.liste – Une page d’accueil résumant l’environnement.>

1118 <p.liste – Une colonne de gauche listant toutes les bases et tables existantes, avec listes déroulantes et lien cliquables. Les bases comporant de nombreuses tables sont paginées par 50 tables.>

1119 <p.liste – Une page détaillant le contenu (liste et caractéristiques des tables) de la base sélectionnée. Le nombre de tables par page est définissable, et les listes sont triables sur l’une ou l’autre colonne – par défaut, ordre alphanumérique des noms des tables.>

1120 <p.liste – Une page permettant de consulter la table sélectionnée, avec pagination paramétrable et tri possible sur l’un ou l’autre index ou colonne – par défaut, sur l’index primaire.>

1121 <p.liste – Sur la page d’accueil, choix de la langue d’affichage.>

1122 <p.liste – Sur la page d’accueil, choix d’un thème.>

1123 <p.liste – Les pages SQL (onglet sur chacun des niveaux général/base de données/table) qui permettent d’exécuter des commandes de toutes sortes.>

1124 <p.liste – Langue, thème général et thème des champs de saisie de commandes SQL sont mémorisés pour chaque utilisateur.>

1125 <espace>

1126 <p <b <u Limitations :>>>

1127 <p.liste – Les onglets ne présentent qu’une page « En préparation » (sauf ceux correspondant aux pages listées ci-dessus).>

1128 <p.liste – Aucune mise à jour autrement que par commandes SQL directes (onglet SQL) n’est possible.>

1129 <p.liste – Le choix d’interclassement n’a aucun effet.>

1130 <p.liste – Deux thèmes seulement sont disponibles.>

1131 <p.liste – Les pages de tables affichant beaucoup de lignes (jusqu’à 500) et de colonnes peuvent mettre plusieurs secondes à s’afficher (le code Python n’est pas encore complètement optimisé).>

1132 <espace>

1133 <p <b <u Points forts :>>>

1134 <coché Plus de 40 langues et variantes sont proposées à la sélection. Ce nombre pourra varier en fonction du remplissage des locales automatiquement, selon le taux défini dans <arial pml.cfg>).>

1135 <coché PyMyAdmin est traduit à 100 % dans 16 langues : allemand, anglais (US et UK), arabe, catalan, coréen, danois, espagnol/castillan, esperanto, estonien, français, grec, italien, néerlandais, polonais, portugais (européen et brésilien) et russe.>

1136 <coché et à plus de 50 % dans 26 autres : albanais, arménien, azeri, bélarusse, bengali, bulgare, chinois (mandarin et simplifié), finnois, galicien, hongrois, indonésien, interlangue, japonais, lituanien, norvégien (bokmal), roumain, serbe, slovaque, slovène, sri-lankais, suédois, tchèque, turc, ukrainien, vietnamien.>

1137

1138 <coché Le sens d’écriture est pleinement pris en compte (arabe, hébreu).>

1139 <p.liste2 <b Note :> Pour forcer une langue non listée, il suffit de la spécifier au lancement dans la ligne de commande/adresse : <arial pymyadmin/login.pml?lang=he> (ex. pour l’hébreu).>

1140 <coché Les champs contenant du texte ont les principaux caractères spéciaux matérialisés soit par un caractère spécial d’une autre couleur (retour de ligne, tabulation, césure optionnelle), soit par un fond coloré (espace insécable, fine…).>

1141 <coché Les fenêtres de saisie de commandes SQL peuvent être définies avec plus de 50 styles différents (le style par défaut étant l’unique disponible avec <arial phpmyadmin> !).>

1142 <coché Lors d’exécution de commandes SQL, chaque résultat est associé à sa commande avec le numéro de la ligne dans la fenêtre initiale, celle-ci restant intacte. Ce qui rend les corrections bien plus aisées quand on a (par exemple) copié-collé plusieurs dizaines de lignes.>

1143 <coché Deux fichiers PML en tout et pour tout (et très peu de javascript) : un pour le login, l’autre (main.pml) faisant tout le reste. Même le code Python spécifique (fonctions/modules.py) est relativement réduit.>

1144 <espace_demi>

1145 <encadré

1146 ———›<p Si vous utilisez PhpMyAdmin quelque part, n’hésitez pas à tester PyMyAdmin !>

1147 ———›<p Quoi qu’il en soit, vous pouvez consulter le code source de PyMyAdmin en le sélectionnant sur la page « comprendre PML ».>

1148 ———›<p <b Vous pouvez également voir des captures d’écran sur la page de PyMyAdmin.>>

1149 ———›>

1150

1151 <chapitre 9. Informations complémentaires>

1152 #=========================================

1153

1154 <sous_chapitre 9.1. Fichiers et routines externes intégrés>

1155 #----------------------------------------------------------

1156 <p <arial pymyadmin> intègre une partie de <arial codemirror> pour la colorisation syntaxique des fenêtres de saisie de commandes, ainsi que deux fichiers <arial css> de <arial jquery> pour permettre le redimensionnement manuel de celles-ci.>

1157

1158 <sous_chapitre 9.2. Remerciements>

1159 #---------------------------------

1160 <p À <b escogriffe> pour ses nombreuses remarques constructives, et notamment :>

1161 <coché la possibilité de suppression des balises inutiles ou redondantes ;>

1162 <coché la possibilité d’« arrondir » les valeurs de propriétés ou de supprimer des propriétés inutiles afin d’harmoniser la mise en forme (et de réduire drastiquement les variantes de style) ;>

1163 <coché la création automatique des espaces non définis (notamment la fine) dans les polices incorporées filtrées <rouge (à venir)>.>

1164


© 2017-2023 Jean-Luc-Blary