tag:linuxfr.org,2005:/tags/typographie/publicLinuxFr.org : les contenus étiquetés avec « typographie »2024-02-19T16:27:19+01:00/favicon.pngtag:linuxfr.org,2005:Bookmark/76332023-12-12T19:58:28+01:002023-12-12T19:58:28+01:00Le « mauvais outil » – à propos de Word, d’accessibilité et de lisibilité<a href="https://www.arthurperret.fr/blog/2023-12-05-le-mauvais-outil.html">https://www.arthurperret.fr/blog/2023-12-05-le-mauvais-outil.html</a> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/134189/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/hellpe/liens/le-mauvais-outil-a-propos-de-word-d-accessibilite-et-de-lisibilite#comments">ouvrir dans le navigateur</a>
</p>
Laurent Pointecouteauhttps://linuxfr.org/nodes/134189/comments.atomtag:linuxfr.org,2005:Bookmark/57682023-01-13T19:25:23+01:002023-01-13T19:25:23+01:00Accessibilité et typographie : qu’est-ce qu’une police de caractères accessible ?<a href="https://blog.hello-bokeh.fr/2023/01/12/accessibilite-et-typographie-quest-ce-quune-police-de-caracteres-accessible/">https://blog.hello-bokeh.fr/2023/01/12/accessibilite-et-typographie-quest-ce-quune-police-de-caracteres-accessible/</a> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/129992/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/ysabeau/liens/accessibilite-et-typographie-qu-est-ce-qu-une-police-de-caracteres-accessible#comments">ouvrir dans le navigateur</a>
</p>
Ysabeau 🧶 🧦https://linuxfr.org/nodes/129992/comments.atomtag:linuxfr.org,2005:Diary/402742022-05-24T14:00:08+02:002022-05-24T14:00:08+02:00PAO, graphisme et colorimétrie dans le libreLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Salut Journal!</p>
<p>Enchanté de faire ta connaissance!</p>
<p>Pour ma première contribution, j'aurai pu simplement poster dans la section <a href="//linuxfr.org/liens">Liens</a>. Mais ce que je m'apprête à partager me semble avoir une plus grande importance et je souhaitais commenter et mettre un peu de contexte.</p>
<p><strong>Le contexte, donc.</strong><br>
Je suis opérateur PAO et on sait, dans le monde du graphisme et de l’édition, que ce sont les logiciels propriétaires qui dominent le marcher, Adobe en tête.<br>
Néanmoins, on sait également, dans le monde du libre, que des alternatives existent. <a href="https://www.gimp.org/">GIMP</a> pour les images matricielles, <a href="https://inkscape.org/fr/">InkScape</a> pour les dessins vectoriels et <a href="https://www.scribus.net/">Scribus</a> pour les mises en pages. Même s’il arrive de lire des critiques à l’encontre des ces logiciels, celles-ci ne sont pas fondées car chacun d’eux (les logiciels libres) est capable de produire du contenu à la hauteur des exigences actuelles du métier.</p>
<p><strong>Le commentaire, ensuite.</strong><br>
Au détour d’échanges sur des salons Telegram, je fais brièvement la connaissance de Jérôme Derieux qui partage un lien vers une section de son site professionnel, <em>encore en élaboration</em> à l’époque. A l’heure actuelle, j’avoue que le contenu est d’une valeur centrale pour qui s’intéresse au domaine de l’édition et du graphisme destiné à l’impression en général.</p>
<p><strong>Les liens, enfin.</strong><br>
<a href="https://jeromederieux.fr">Le site de Jérôme</a> où il y présente son travail de graphiste professionnel. Mais, la partie qui nous intéresse se trouve <a href="https://jeromederieux.fr/cmjn/">ici avec la table des matières</a>. On y trouve notamment, et non-exhaustivement:<br>
- <a href="https://jeromederieux.fr/cmjn/rvb-et-cmjn/">de la théorie sur les couleurs</a>;<br>
- <a href="https://jeromederieux.fr/cmjn/rvb-et-cmjn-la-pratique/">de la théorie sur la gestion colorimétrique</a>;<br>
- <a href="https://jeromederieux.fr/cmjn/images-et-resolution-la-theorie/">de la théorie sur les résolutions des images matricielles</a>;<br>
- <a href="https://jeromederieux.fr/cmjn/gestion-de-la-couleur-avec-gimp/">comment régler la colorimétrie dans GIMP</a>;<br>
- <a href="https://jeromederieux.fr/cmjn/reglage-de-la-gestion-des-couleurs-dans-scribus/">comment régler la colorimétrie dans Scribus</a>;<br>
- <a href="https://jeromederieux.fr/cmjn/reglage-de-la-gestion-des-couleurs-dans-inkscape/">comment régler la colorimétrie dans InkScape</a>;<br>
- <a href="https://jeromederieux.fr/cmjn/exporter-un-pdf-dimpression-depuis-scribus/">comment exporter un PDF prêt pour l’impression depuis Scribus</a>;<br>
- quelques astuces;<br>
- etc.</p>
<p>Les sections et les articles s'étoffent au fur et à mesure. Ce site est une véritable mine d’informations pour les gens du métier et les amateurs qui souhaite mettre la main à la pâte. C’est clair, concis, efficace et en français, s’il vous plaît.</p>
<p>Bonne fin de journée, 'nal! ;-)</p>
<div><a href="https://linuxfr.org/users/oinska/journaux/pao-graphisme-et-colorimetrie-dans-le-libre.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/127835/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/oinska/journaux/pao-graphisme-et-colorimetrie-dans-le-libre#comments">ouvrir dans le navigateur</a>
</p>
oinskahttps://linuxfr.org/nodes/127835/comments.atomtag:linuxfr.org,2005:Diary/401292022-02-05T12:15:49+01:002022-02-25T14:09:43+01:00rétrospective sur la mise en page en console<h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li><a href="#toc-intro-au-kilom%C3%A8tre">intro au kilomètre</a></li>
<li><a href="#toc-replis-sur-bord-de-lignes">replis sur bord de lignes</a></li>
<li><a href="#toc-ajustement-des-paragraphes-%C3%A0-une-largeur">ajustement des paragraphes à une largeur</a></li>
<li><a href="#toc-expansion-au-taquet">expansion au taquet</a></li>
<li><a href="#toc-paragraphes-au-large">paragraphes au large</a></li>
<li><a href="#toc-balle-au-centre-et-%C3%A9galisation">balle au centre et égalisation</a></li>
<li><a href="#toc-impressions-standards">impressions standards</a></li>
<li><a href="#toc-impressions-en-rang-etou-partielles">impressions en rang et/ou partielles</a></li>
<li><a href="#toc-impressions-de-livrets">impressions de livrets</a></li>
<li><a href="#toc-chasse-fixe">chasse fixe</a></li>
</ul>
<p>'jour 'nal.</p>
<p>Dans <a href="//linuxfr.org/users/elessar/journaux/des-concepteurs-qui-ont-eteint-trop-tot-leur-cerveau#comment-1874132">une enfilage sur le clavier</a>, j'avais avoué ma passion pour l'histoire des systèmes et matériels informatiques ; et dans diverses autres discussion, ici et ailleurs, j'ai souvent évoqué l'influence des <a href="https://fr.wikipedia.org/wiki/T%C3%A9l%C3%A9scripteur">télescripteurs</a> (en tant que <a href="https://fr.wikipedia.org/wiki/P%C3%A9riph%C3%A9rique_informatique#Types_de_p%C3%A9riph%C3%A9riques">périphériques d'entrée-sortie</a>) sur le <a href="https://fr.wikipedia.org/wiki/UNIX_System_V">système Unix</a>, un <a href="//linuxfr.org/users/mrspackman/journaux/l-esprit-unix-une-culture-des-mots">processeur de textes commandé textuellement</a>…<br>
C'est cet aspect que j'aimerais rappeler à travers quelques commandes oubliées.</p>
<h2 id="toc-intro-au-kilomètre">intro au kilomètre</h2>
<p>J'ai souvenir qu'on enseignait à une certaine époque (j'ai l'impression que ce n'est plus vrai quand je regarde autour de moi) que dans la création de documents textes (lettre, rédaction, roman, etc.) il y a deux étapes distinctes : la saisie (dite <a href="https://consomatique.fr/saisie-de-texte-au-kilometre-quest-ce-que-cest/">au kilomètre</a>) d'une part, et la mise en forme d'autre part. Un éditeur comme <em>Vi</em> permet d'observer cette règle facilement : on est en mode insertion pour la partie de saisie, et en mode commandes pour la partie édition avant mise en forme…</p>
<p>Lors de cette phase de saisie brute, les traitements de texte moderne nécessitent de <a href="https://www.memoclic.com/448-word/18940-saisie-au-kilometre.html">distinguer le simple saut de ligne du changement de paragraphe (qui est associé à la touche Entrée)</a>. Dans un <a href="https://fr.wikipedia.org/wiki/%C3%89diteur_de_texte">éditeur de texte</a>, que ce soit pour avec un <a href="https://fr.wikipedia.org/wiki/Langage_de_balisage_l%C3%A9ger">balisage</a> ou directement pour l'imprimante comme dans le cas présent, c'est plus simple : la touche Entrée permet de juste passer à la ligne (ce qui est rarement nécessaire), et il faut sauter au moins une ligne pour indiquer un nouveau paragraphe.</p>
<p>Une fois son texte saisi (input mode) et corrigé (command mode), il faut le mettre en forme pour l'impression (ou l'affichage sur le <a href="https://fr.wikipedia.org/wiki/Terminal_%28informatique%29">terminal</a>…) Les systèmes <em>Unix</em> offrent quelques outils pour cela.</p>
<h2 id="toc-replis-sur-bord-de-lignes">replis sur bord de lignes</h2>
<p>Le premier, peu connu, est <a href="http://pubs.opengroup.org/onlinepubs/9699919799/utilities/fold.html#top">le filtre POSIX "<code>fold</code>"</a>, apparu dans <a href="https://en.wikipedia.org/wiki/Berkeley_Software_Distribution">1BSD</a> en 1977 (sortie officielle de la distribution en mars 1978). On lui indique la largeur voulue avec l'option "<code>-w</code>" (par défaut c'est du 80 caractères…) Il va être utile pour adapter la largeur du texte, en particulier lorsqu'on l'envoie vers une imprimante (sans retour de ligne, les lignes trop longues sont juste tronquées…) On peut l'utiliser aussi pour voir le résultat du même texte avec une largeur d'écran différente. Exemple :</p>
<pre><code class="console"><span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"The _fold_ utility is a filter that shall fold lines from its\</span>
<span class="s2">input files, but breaking the lines to have a maximum of _width_\</span>
<span class="s2">column position (or bytes, if the *-b* option is specified)."</span> <span class="p">|</span> fold
<span class="go">The _fold_ utility is a filter that shall fold lines from its input files, but b</span>
<span class="go">reaking the lines to have a maximum of _width_ column position (or bytes, if the</span>
<span class="go"> *-b* option is specified).</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"The _fold_ utility is a filter that shall fold lines from its\</span>
<span class="s2">input files, but breaking the lines to have a maximum of _width_\</span>
<span class="s2">column position (or bytes, if the *-b* option is specified)."</span> <span class="p">|</span> fold -w <span class="m">75</span>
<span class="go">The _fold_ utility is a filter that shall fold lines from its input files,</span>
<span class="go">but breaking the lines to have a maximum of _width_ column position (or byt</span>
<span class="go">es, if the *-b* option is specified).</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"The _fold_ utility is a filter that shall fold lines from its\</span>
<span class="s2">input files, but breaking the lines to have a maximum of _width_\</span>
<span class="s2">column position (or bytes, if the *-b* option is specified)."</span> <span class="p">|</span> fold -w <span class="m">60</span>
<span class="go">The _fold_ utility is a filter that shall fold lines from it</span>
<span class="go">s input files, but breaking the lines to have a maximum of _</span>
<span class="go">width_ column position (or bytes, if the *-b* option is spec</span>
<span class="go">ified).</span></code></pre>
<p>Le fonctionnement est un peu simplet : noter la coupe abrupt des mots …sauf si on utilise l'option "<code>-s</code>" qui demande de couper aux espaces !</p>
<pre><code class="console"><span class="gp">$</span> fold wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~its~input~files,~but~b</span>
<span class="go">reaking~the~lines~to~have~a~maximum~of~_width_~column~position~(or~bytes,~if~the</span>
<span class="go">~*-b*~option~is~specified).</span>
<span class="go">Use~*-s*~option~to~split~at~latest~space~before~maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each~paragraph~from~its~input~</span>
<span class="go">files,~but~break~the~lines~to~have~a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> fold -s wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~its~input~files,~but~</span>
<span class="go">breaking~the~lines~to~have~a~maximum~of~_width_~column~position~(or~bytes,~if~</span>
<span class="go">the~*-b*~option~is~specified).</span>
<span class="go">Use~*-s*~option~to~split~at~latest~space~before~maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each~paragraph~from~its~input~</span>
<span class="go">files,~but~break~the~lines~to~have~a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> fold -s -w <span class="m">75</span> wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~its~input~files,~</span>
<span class="go">but~breaking~the~lines~to~have~a~maximum~of~_width_~column~position~(or~</span>
<span class="go">bytes,~if~the~*-b*~option~is~specified).</span>
<span class="go">Use~*-s*~option~to~split~at~latest~space~before~maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each~paragraph~from~its~</span>
<span class="go">input~~files,~but~break~the~lines~to~have~a~maximum~of~_width_~column~</span>
<span class="go">position.</span>
<span class="gp">$</span> fold -w <span class="m">60</span> -s wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum~</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option~is~</span>
<span class="go">specified).</span>
<span class="go">Use~*-s*~option~to~split~at~latest~space~before~maximum~</span>
<span class="go">_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each~</span>
<span class="go">paragraph~from~its~input~files,~but~break~the~lines~to~have~</span>
<span class="go">a~maximum~of~_width_~column~position.</span></code></pre>
<p>J'utilise cette commande dans mes scripts pour des traitements caractère par caractère :</p>
<pre><code class="sh"><span class="c1"># from variable</span>
<span class="k">for</span> char in <span class="k">$(</span><span class="nb">echo</span> <span class="s2">"</span><span class="nv">$var</span><span class="s2">"</span> <span class="p">|</span> fold -w <span class="m">1</span><span class="k">)</span><span class="p">;</span> <span class="k">do</span> stuff<span class="p">;</span> <span class="k">done</span>
<span class="c1"># from file</span>
<span class="k">for</span> char in <span class="k">$(</span>fold -w <span class="m">1</span> <span class="s2">"</span><span class="nv">$filepath</span><span class="s2">"</span><span class="k">)</span><span class="p">;</span> <span class="k">do</span> stuff<span class="p">;</span> <span class="k">done</span></code></pre>
<p>…chose qu'on peut faire aussi à l'aide de <code>grep</code> :</p>
<pre><code class="sh"><span class="c1"># from variable</span>
<span class="k">for</span> char in <span class="k">$(</span><span class="nb">echo</span> <span class="s2">"</span><span class="nv">$var</span><span class="s2">"</span> <span class="p">|</span> grep -os <span class="s1">'.'</span><span class="k">)</span><span class="p">;</span> <span class="k">do</span> stuff<span class="p">;</span> <span class="k">done</span>
<span class="c1"># from file</span>
<span class="k">for</span> char in <span class="k">$(</span>grep -os <span class="s1">'.'</span> <span class="s2">"</span><span class="nv">$filepath</span><span class="s2">"</span><span class="k">)</span><span class="p">;</span> <span class="k">do</span> stuff<span class="p">;</span> <span class="k">done</span></code></pre>
<h2 id="toc-ajustement-des-paragraphes-à-une-largeur">ajustement des paragraphes à une largeur</h2>
<p>Il existe un autre filtre, apparu dans <a href="https://en.wikipedia.org/wiki/History_of_the_Berkeley_Software_Distribution#2BSD_%28PDP-11%29">2BSD</a> en 1978 et vite adopté par d'autres distributions. Il porte le nom de "<code>fmt</code>" pour "ForMat Text"… (En dehors du système, c'est un sigle qui peut avoir plusieurs sens en <a href="https://fr.wikipedia.org/wiki/FMT">français</a> comme en <a href="https://en.wikipedia.org/wiki/FMT">anglais</a> et ailleurs. Dans de nombreux langages de programmation, c'est souvent le nom de la <a href="http://fmtlib.net/latest/index.html">bibliothèque pour faire du formatage de données —textes/nombres/etc.</a>, cousin de "<code>printf</code>"/"<code>sprintf</code>" anciennement connu sous le nom de "<a href="https://isocpp.org/blog/2016/05/cppformat-3.0.0-and-becomes-fmt-victor-zverovich"><code>cppformat</code></a>" et est utilisé par exemple dans <a href="https://golang.org/pkg/fmt/">Go</a> et dans <a href="http://www.codejava.net/java-ee/jstl/jstl-format-tag-formatnumber">Java EE en tant que JSTL</a> etc.) On lui indique aussi la largeur voulue avec l'option "<code>-w</code>" (qui est de 75 caractères par défaut …parce que conçu avec la <a href="https://fr.wikipedia.org/wiki/N%C3%A9tiquette">nétiquette</a> et <a href="https://stackoverflow.com/a/23928579/1699311">les RFC du courriel</a> en tête)</p>
<pre><code class="console"><span class="gp">$</span> fmt wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~its~input~files,</span>
<span class="go">but~breaking~the~lines~to~have~a~maximum~of~_width_~column~position~</span>
<span class="go">(or~bytes,~if~the~*-b*~option~is~specified).~~Use~*-s*~option~to~split</span>
<span class="go">at~latest~space~before~maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each~paragraph~from</span>
<span class="go">its~input~ files,~but~break~the~lines~to~have~a~maximum~of~_width_</span>
<span class="go">column~position.</span>
<span class="gp">$</span> fmt -w <span class="m">80</span> wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~its~input~files,</span>
<span class="go">but~breaking~the~lines~to~have~a~maximum~of~_width_~column~position~(or~bytes,</span>
<span class="go">if~the~*-b*~option~is~specified).~~Use~*-s*~option~to~split~at~latest~space</span>
<span class="go">before~maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each~paragraph~from~its</span>
<span class="go">input~files,~but~break~the~lines~to~have~a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> fmt -w <span class="m">60</span> wrap.txt <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option</span>
<span class="go">is~specified).~~Use~*-s*~option~to~split~at~latest~space</span>
<span class="go">before~maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each</span>
<span class="go">paragraph~from~its~input~files,~but~break~the~lines~to</span>
<span class="go">have~a~maximum~of~_width_~column~position.</span></code></pre>
<p>Il met en œuvre la notion de mots comme suite de caractères séparés par des blancs, et reconnait la notion de paragraphe comme étant séparés par une ou plusieurs lignes vides (comme <code>vi</code> hé hé). Du coup, il peut <a href="https://french.stackexchange.com/questions/10958/utilisation-des-retraits-au-d%C3%A9but-des-paragraphes">appliquer un retrait à la première ligne du paragraphe</a> (option "<code>-p</code>" de l'implémentation BSD) …ou carrément l'inverse (option "<code>-t</code>" de l'implémentation GNU). Eh oui, la typographie n'a pas attendu les traitements de texte… (voir <a href="https://support.office.com/fr-fr/article/Cr%C3%A9er-un-retrait-de-premi%C3%A8re-ligne-5788cf53-3ce9-4381-bd3a-2819c538ecd9">ci</a> et <a href="http://www.commentcamarche.net/contents/1651-word-regler-le-retrait-des-paragraphe">là</a> ou <a href="http://coursvallee.purebackend.com/word/ateliers_word/atelier_9_word/atelier_9_word.htm">là</a> par exemple.)<br><br>
On notera qu'il connait aussi la notion de phrase comme étant terminées par une ponctuation de fin (point… final, d'interrogation, d'exclamation, en fait comme dans <code>vi</code> hé hé) et peuvent alors appliquer la règle typographique anglophone d'espacement (datant de l'époque des machines à écrire et devant faciliter la lecture) : un seul espace entre les mots et deux espaces entre les phrases. (BSD "<code>-s</code>" ou GNU "<code>-u</code>") Noter que la commande "<code>J</code>" de <em>Ed</em>/<em>Ex</em>/<em>Vi</em> procède normalement ainsi…<br>
D'autres implémentations peuvent offrir de centrer le texte sur la ligne ou d'autres options sympathiques, comme de conserver les lignes dans les paragraphes (GNU "<code>-s</code>")</p>
<table>
<thead>
<tr>
<th>
<a href="https://man.openbsd.org/fmt">OpenBSD</a>/<a href="https://www.freebsd.org/cgi/man.cgi?query=fmt&sektion=1&apropos=0&manpath=FreeBSD+6.2-RELEASE">FreeBSD</a>
</th>
<th><a href="https://linux.die.net/man/1/fmt">GNU/Linux</a></th>
<th><a href="https://docs.oracle.com/cd/E23823_01/html/816-5165/fmt-1.html#scrolltoc">Sun Solaris</a></th>
<th><a href="http://plan9.bell-labs.com/magic/man2html/1/fmt">Plan 9</a></th>
<th><a href="http://publib16.boulder.ibm.com/doc_link/en_US/a_doc_lib/cmds/aixcmds2/fmt.htm">IBM AIX</a></th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td>use <code>Ⅰ</code> width output (default goal is around 93% of width)</td>
</tr>
<tr>
<td><code>-Ⅰ</code></td>
<td><code>-Ⅰ</code></td>
<td><code>-Ⅰ</code></td>
<td><code>-l Ⅰ</code></td>
<td><code>-Ⅰ</code></td>
<td>use <code>Ⅰ</code> width output</td>
</tr>
<tr>
<td><code>Ⅰ</code></td>
<td><code>-g Ⅰ</code></td>
<td></td>
<td></td>
<td></td>
<td>goal is <code>Ⅰ</code> (and max width is <code>Ⅰ+10</code> unless specified)</td>
</tr>
<tr>
<td><code>Ⅰ Ⅼ</code></td>
<td><code>-g Ⅰ -w Ⅼ</code></td>
<td></td>
<td></td>
<td></td>
<td>goal is <code>Ⅰ</code> and max width is <code>Ⅼ</code>
</td>
</tr>
<tr>
<td><code>-c</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>Center</td>
</tr>
<tr>
<td><code>-d Ⅹ</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>sentence ending Delimiters are <code>Ⅹ</code>
</td>
</tr>
<tr>
<td><code>-l Ⅰ</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>replace <code>Ⅰ</code> spaces with tabs at beginning of line</td>
</tr>
<tr>
<td><code>-m</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>try to format Mail headers too</td>
</tr>
<tr>
<td><code>-n</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>disable Nroff compatibility so not skip lines starting with '.'</td>
</tr>
<tr>
<td><code>-p</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>indent Paragraph first line</td>
</tr>
<tr>
<td></td>
<td><code>-t</code></td>
<td></td>
<td></td>
<td></td>
<td>Tagged paragraph (indent lines but first)</td>
</tr>
<tr>
<td><code>-s</code></td>
<td><code>-u</code></td>
<td></td>
<td></td>
<td></td>
<td>Uniformize white spaces by Single one/two between words/sentences</td>
</tr>
<tr>
<td><code>-t Ⅰ</code></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>replace Tabs with <code>Ⅰ</code> spaces instead of 1</td>
</tr>
<tr>
<td></td>
<td><code>-p Ⅹ</code></td>
<td></td>
<td></td>
<td></td>
<td>reformat only lines beginning with <code>Ⅹ</code> Prefix</td>
</tr>
<tr>
<td></td>
<td><code>-c</code></td>
<td><code>-c</code></td>
<td></td>
<td></td>
<td>preserve indentation of first two lines = Crown margin</td>
</tr>
<tr>
<td></td>
<td><code>-s</code></td>
<td><code>-s</code></td>
<td><code>-j</code></td>
<td></td>
<td>Split/fold only long lines but do not refill (i.e. Join short lines)</td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
<td><code>-i Ⅰ</code></td>
<td></td>
<td>Indent each line with <code>Ⅰ</code> spaces</td>
</tr>
</tbody>
</table>
<p>Ceci dit, il ne faut se limiter qu'à une option, "<code>-w…</code>" (voire même juste "<code>-…</code>" puisque <a href="https://stackoverflow.com/a/17225565/1699311">d'anciennes implémentation AIX ne connaissent que ce dernier</a> mais que cette dernière forme n'est pas reconnue sur Plan 9…)<br><br>
Pour le travail de base, "<code>fmt</code>" est quasiment équivalent à "<code>fold -s</code>". Ainsi, <a href="https://inconsolation.wordpress.com/2013/11/07/fmt-and-the-difference-is/"><code>fold</code> reste intéressant quand il faut respecter les sauts de lignes, tandis que <code>fmt</code> va formater un paragraphe en essayant d'avoir un texte homogène…</a></p>
<h2 id="toc-expansion-au-taquet">expansion au taquet</h2>
<p>Pour les tabulations, il existe des filtres POSIX qu'il vaut mieux utiliser en amont ; ça rend les scripts plus portables.</p>
<table>
<thead>
<tr>
<th>BSD <code>fmt</code>
</th>
<th>alternative POSIX</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>-t _</code></td>
<td><a href="http://www.opengroup.org/onlinepubs/9699919799/utilities/expand.html#top"><code>expand -t _</code></a></td>
</tr>
<tr>
<td><code>-l _</code></td>
<td><a href="http://www.opengroup.org/onlinepubs/9699919799/utilities/unexpand.html#top"><code>unexpand -t _</code></a></td>
</tr>
</tbody>
</table>
<p>Les filtres dédiés permettent d'ailleurs de faire beaucoup plus…</p>
<pre><code class="console"><span class="gp">$</span> cat -T taquets.txt
<span class="go">Fournitures^IQuantité^IPrix</span>
<span class="go">Crayons^I12^I15,76</span>
<span class="go">Feuilles A4^I1000^I137,5</span>
<span class="go">Correcteurs^I10^I18</span>
<span class="gp">$</span> <span class="c1"># par défaut on positionne en colonne modulo 8...</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> cat taquets.txt
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> cut -f <span class="m">1</span>-3 taquets.txt
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># cas par défaut de la commande qui remplace TAB par 8</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> expand taquets.txt
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># mais on peut spécifier une autre largeur de TAB comme 7</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> expand -t <span class="m">7</span> taquets.txt
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># On peut mettre des Taquets par exemple en colonnes 17 et 33</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> expand -t <span class="m">17</span>,33 taquets.txt
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># On peut mettre des Taquets par exemple en colonnes 13 et 23</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> expand -t <span class="m">13</span>,23 taquets.txt
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># On peut redefinir les taquets pour le terminal</span>
<span class="gp">$</span> <span class="c1"># (profite à tous les programmes)</span>
<span class="gp">$</span> tabs <span class="m">13</span>,23 <span class="p">;</span> <span class="nb">echo</span> <span class="s2">"1------.-1-------.-2-------.-3"</span> <span class="p">;</span> cat taquets.txt <span class="p">;</span> tabs -8
<span class="go">1------.-1-------.-2-------.-3-------.-</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span></code></pre>
<p>On savait déjà faire tout cela en ligne de commande dans ces années là (pour la petite histoire, <a href="https://man.openbsd.org/expand.1"><code>expand</code></a> est apparue avec 1BSD en mars 1978, et <a href="http://pubs.opengroup.org/onlinepubs/9699919799/utilities/tabs.html"><code>tabs</code></a> est apparu dans <a href="https://fr.wikipedia.org/wiki/PWB/UNIX">PWB/UNIX</a> publié en juillet 1977.) Encore une fois, pas eu besoin d'attendre la machinerie moderne (voir <a href="http://www.commentcamarche.net/contents/1709-word-tabulations">ici</a> et <a href="https://www.votreassistante.net/creer-taquets-de-tabulations-word/">là</a> ou <a href="http://questionbureautique.over-blog.com/article-tabulations-sous-word-120104572.html">là</a> par exemple.)</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># attention a bien les enchaîner....</span>
<span class="gp">$</span> fold -w <span class="m">60</span> taquets.txt
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> fmt -w60 taquets.txt
<span class="go">Fournitures Quantité Prix Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5 Correcteurs 10 18</span>
<span class="gp">$</span> fmt -s -w <span class="m">60</span> taquets.txt
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> fmt -s -w <span class="m">60</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span></code></pre>
<p>Pour la route, si on n'est pas préoccupé par la portabilité, il y a d'autres alternatives à <code>expand</code> :</p>
<ul>
<li>
<a href="https://www.netadmintools.com/art327.html#wbounce-modal"><code>tab2space</code></a> du projet <a href="http://tidy.sourceforge.net"><em>HTML Tidy</em></a> et qui a la particularité de combiner l'équivalent de <code>expand</code> (une seule largeur de tabulation) avec l'équivalent de <a href="https://opensharing.fr/commandes-linux-dos2unix"><code>dos2unix</code> ou <code>fromdos</code></a>. C'est présent dans <em>Mac OS X</em> et <a href="https://docs.oracle.com/cd/E88353_01/html/E37839/tab2space-1.html">Solaris</a> entre autres.</li>
<li>la commande <a href="https://vim.fandom.com/wiki/Super_retab"><code>retab</code> dans <em>Vim</em></a> et peut être <a href="https://gist.github.com/snim2/223491">vite implémenté dans Emacs</a> et dans <a href="https://github.com/liuqx0717/tabs-to-spaces/blob/master/tab2space.sln">VSC</a>
</li>
<li>etc.</li>
</ul>
<h2 id="toc-paragraphes-au-large">paragraphes au large</h2>
<p>Il semble qu'il y a matière à améliorations, surtout dans le cadre du courriel, ce qui a conduit <a href="http://www.nicemice.net/amc/">Adam M. Costello</a> à produire "<a href="http://www.nicemice.net/par/"><code>par</code></a>" en 1993 (juste l'abréviation de « <em>PARagraph</em> » je crois, mais c'aurait pu être le sigle de « <em>Paragraphs Alternative Reformater</em> » aussi.) Je ne maitrise pas sa <a href="http://www.nicemice.net/par/par-doc.var">syntaxe peu évidente</a> ; mais il sait traiter :</p>
<ul>
<li>les mails (option "<code>q</code>" ajustable avec "<code>Q...</code>" et combinable avec "<code>i</code>" et "<code>e</code>")</li>
<li>les marges (options "<code>p</code>" et "<code>s</code>" pouvant être combiné avec "<code>t</code>" ou "<code>f</code>")</li>
<li>les imbrications de commentaires et messages cités (options "<code>d</code>")</li>
<li>la préservation des espaces initiaux (option "<code>r</code>")</li>
<li>les justification (option "<code>j</code>") et la dernière ligne (option "<code>l</code>")</li>
<li>le remplissage quasi complet (option "<code>f</code>") sans justification</li>
<li>l'expansion de la tabulation (option "<code>T...</code>")</li>
<li>et le retrait des lignes superflues (option "<code>e</code>")</li>
<li>et d'autres choses (options "<code>c</code>" et "<code>h</code>" et "<code>g</code>" par exemple)</li>
</ul>
<p>le tout en gérant l'Unicode (en UTF-8) ! La largeur est aussi indiquée avec "<code>-w ...</code>" (on peut utiliser juste "<code>w...</code>" ou "<code>...</code>") et est par défaut <code>72</code>…</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># attention par n'opère que comme filtre...</span>
<span class="gp">$</span> par -w <span class="m">60</span> wrap.txt
<span class="go">par error:</span>
<span class="go">bad argument: wrap.txt</span>
<span class="go">options for par:</span>
<span class="go">help print option summary ---------- Boolean parameters. ---------</span>
<span class="go">version print version number b<body> let non-trailing body chars in</span>
<span class="go">B<op><set> as <op> is =/+/- prefix, non-leading in suffix</span>
<span class="go"> replace/augment/diminish c<cap> count all words as capitalized</span>
<span class="go"> body chars by <set> d<div> use indentation as a delimiter</span>
<span class="go">P<op><set> ditto for protective chars E<Err> send messages to stderr</span>
<span class="go">Q<op><set> ditto for quote chars e<expel> discard superfious lines</span>
<span class="go">-------- Integer parameters: -------- f<fit> narrow paragraph for best fit</span>
<span class="go">h<hang> skip IP's 1st <hang> lines g<guess> preserve wide sentence breaks</span>
<span class="go"> in scan for common affixes i<invis> hide lines inserted by <quote></span>
<span class="go">p<prefix> prefix length j<just> justify paragraphs</span>
<span class="go">r<repeat> if not 0, force bodiless l<last> treat last lines like others</span>
<span class="go"> lines to length <width> q<quote> supply vacant lines between</span>
<span class="go">s<suffix> suffix length different quote nesting levels</span>
<span class="go">T<tab> tab stops every <tab> cols R<report> print error for too-long words</span>
<span class="go">w<width> max output line length t<touch> move suffixes left</span>
<span class="go">See par.doc or par.1 (the man page) for more information.</span>
<span class="gp">$</span> <span class="c1"># ...il lit l'entrée standard et écrit sur la sortie standard</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"_par_ is a filter which reformates each paragraph from its input</span>
<span class="go">to its output" | par</span>
<span class="go">_par_ is a which reformates each paragraph from its input to its</span>
<span class="go">output</span>
<span class="gp">$</span> <span class="c1"># donc envoyer d'abord le fichier sur l'entrée standard...</span>
<span class="gp">$</span> cat wrap.txt <span class="p">|</span> par -w <span class="m">60</span> <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from~~.</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum~~.</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option~is.</span>
<span class="go">specified)~Use~*-s*~option~to~split~at~latest~space~before~.</span>
<span class="go">maximum~_width_~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each</span>
<span class="go">paragraph~from~its~input~files,~but~break~the~lines~to~have</span>
<span class="go">a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> <span class="c1"># les points systématiques à la fin de ligne sont reproduits</span>
<span class="gp">$</span> <span class="c1"># ...donc lui signaler qu'il n'y a pas de délimiteur de fin</span>
<span class="gp">$</span> cat wrap.txt <span class="p">|</span> par -w <span class="m">60</span> -s <span class="m">0</span> <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option~is</span>
<span class="go">specified)~Use~*-s*~option~to~split~at~latest~space~before</span>
<span class="go">maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each</span>
<span class="go">paragraph~from~its~input~files,~but~break~the~lines~to~have</span>
<span class="go">a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> <span class="c1"># ...ou ajouter le point dans la liste des caractères normaux</span>
<span class="gp">$</span> cat wrap.txt <span class="p">|</span> par -w <span class="m">60</span> -B+. <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option~is</span>
<span class="go">specified)~Use~*-s*~option~to~split~at~latest~space~before</span>
<span class="go">maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each</span>
<span class="go">paragraph~from~its~input~files,~but~break~the~lines~to~have</span>
<span class="go">a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> <span class="c1"># essayons d'avoir des lignes plus équilibrées, comme fmt...</span>
<span class="gp">$</span> cat wrap.txt <span class="p">|</span> par -w60fs0 <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~is~a~filter~that~shall~fold~lines~from</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option~is</span>
<span class="go">specified)~Use~*-s*~option~to~split~at~latest~space~before</span>
<span class="go">maximum~_width_.</span>
<span class="go">The~_fmt_~utility~is~a~filter~that~shall~reformat~each</span>
<span class="go">paragraph~from~its~input~files,~but~break~the~lines~to</span>
<span class="go">have~a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> <span class="c1"># on peut carrément vouloir justifier les lignes...</span>
<span class="gp">$</span> cat wrap.txt <span class="p">|</span> par -w60j <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~~is~a~filter~that~shall~~fold~lines~from.</span>
<span class="go">its~input~files,~~but~breaking~the~lines~to~~have~a~maximum.</span>
<span class="go">of~_width_~column~position~(or~bytes,~if~the~*-b*~option~is.</span>
<span class="go">specified)~Use~*-s*~option~to~~split~at~latest~space~before.</span>
<span class="go">maximum~_width_~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~.</span>
<span class="go">The~~_fmt_~utility~~is~~a~filter~~that~~shall~reformat~~each</span>
<span class="go">paragraph~from~its~input~files,~~but~break~the~lines~to have</span>
<span class="go">a~maximum~of~_width_~column~position.</span>
<span class="gp">$</span> <span class="c1"># ...sans oublier de combiner le reste...</span>
<span class="gp">$</span> cat wrap.txt <span class="p">|</span> par 60js0 <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">The~_fold_~utility~~is~a~filter~~that~shall~~fold~lines~from</span>
<span class="go">its~input~files,~but~breaking~the~lines~to~have~a~maximum~of</span>
<span class="go">_width_~column~~position~(or~~bytes,~if~the~~*-b*~~option~is</span>
<span class="go">specified).~Use~*-s*~option~to~~split~at~latest~space~before</span>
<span class="go">maximum~_width_.</span>
<span class="go">The~~_fmt_~utility~~is~~a~filter~~that~~shall~reformat~~each</span>
<span class="go">paragraph~from~its~input~files,~~but~break~the~lines~to have</span>
<span class="go">a~maximum~of~_width_~column~position.</span></code></pre>
<p><code>par</code> est aussi bien pour reformater des mails (format texte) ! Mais dans beaucoup de cas, il est assez compliqué à mon avis… À réserver donc aux rares cas où les autres ne satisfont pas.</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># comme "fmt" mais les tabulations deviennent un espace...</span>
<span class="gp">$</span> cat taquets.txt <span class="p">|</span> par -w <span class="m">60</span>
<span class="go">Fournitures Quantité Prix Crayons 12 15,76 Feuilles A4 1000</span>
<span class="go">137,5 Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># je ne suis pas parvenu à utiliser cette option</span>
<span class="gp">$</span> cat taquets.txt <span class="p">|</span> par -w <span class="m">60</span> -T <span class="m">8</span>
<span class="go">Fournitures Quantité Prix 12 5,76 A4 137,5 urs 10 8</span>
<span class="gp">$</span> <span class="c1"># on peut au moins arriver à préserver les sauts de ligne...</span>
<span class="gp">$</span> par -w <span class="m">60</span> -d < taquets.txt
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># on peut demander de préserver les 23 premiers caractères...</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> par w60p23
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span></code></pre>
<p>Il a le mérite d'exister et d'être présent dans de plus en plus de distributions, sinon <a href="http://www.nicemice.net/par/build-hints.var">se porte facilement</a>. À surveiller.</p>
<h2 id="toc-balle-au-centre-et-égalisation">balle au centre et égalisation</h2>
<p>Pour le centrage, il faut hélas recourir à "<a href="https://stackoverflow.com/a/12477090/1699311"><code>printf</code></a>" (ou "<a href="https://stackoverflow.com/a/12472021/1699311"><code>perl</code></a>" ou "<a href="https://www.unix.com/302288634-post3.html"><code>sed</code></a>" ou autre) puis <a href="https://superuser.com/a/829870/161454">boucler sur toutes les lignes</a> (ce qui peut se faire avec "<a href="https://superuser.com/a/915899/161454"><code>awk</code></a>" qui est <a href="https://unix.stackexchange.com/a/96115/23889">mon filtre favori dans ce cas ci</a>…)<br>
Nota : <a href="https://unix.stackexchange.com/a/94758/23889"><em>Vim</em> a la commande "<code>:center</code>" qui fait bien cela</a> ; ainsi que "<code>:right</code>" et "<code>:left</code>", et tous les trois peuvent s'abréger à 2 caractères et on peut indiquer ensuite la largeur voulue (80 sinon).</p>
<p>Concernant la pleine justification, c'est un processus plus couteux qui se fait en répartissant astucieusement des espaces entre les mots (chose que savent faire <a href="https://superuser.com/a/171624/161454"><em>Emacs</em></a> et <a href="https://superuser.com/a/637512/161454"><em>Nano</em></a> ; et sinon ça <a href="https://superuser.com/a/171642/161454">se scripte dans un langage un peu avancé</a>.) Ce procédé est bien connu, mais <a href="https://en.wikipedia.org/wiki/Typographic_alignment#Problems_with_justification">le résultat n'est pas toujours des plus heureux et se retrouve facilement avec des fleuves qui sillonnent le texte…</a><br><br>
Idéalement, pour faire de la justification, il faut certes ajouter des blancs ci et là, mais arriver à limiter le nombre de ceux-ci et jouer également avec la <a href="https://fr.wikipedia.org/wiki/C%C3%A9sure_%28typographie%29">césure des mots</a> (ou « <a href="https://en.wikipedia.org/wiki/Hyphen#Justification_and_line-wrapping">hyphenation</a> » en anglais, qui se fait avec le <a href="https://fr.wikipedia.org/wiki/Trait_d%27union#Codage_informatique">trait d'union</a>…) dont les règles varient selon les langues. On peut par exemple s'appuyer sur un « dictionnaire » dédié. C'est d'ailleurs l'approche des logiciels pionniers : <em>Justify</em>, puis <em>TJ-1</em> et enfin <a href="http://www.dpbsmith.com/tj2.html"><em>TJ-2</em> en 1963</a>, pour la machine <a href="https://en.wikipedia.org/wiki/PDP-1">PDP-1</a>, ne traitent que l'anglais en utilisant un dictionnaire de césures… On le considère parfois comme le premier « processeur de texte » (ou « traitement de texte », buzzword du NY Times en 1971) en tant que machine dédiée (comme <em>Dorsey</em>) et non logiciel (comme <em>Vydec</em>)…</p>
<h2 id="toc-impressions-standards">impressions standards</h2>
<p>Voyons maintenant une dernière commande, apparue avec la première version officielle distribuée aux universités vers 1971 mais déjà utilisé au Bell Labs (en fait <a href="https://framablog.org/2009/08/10/unix-40-ans/">il nait en août 1969</a> mais <a href="http://www.commentcamarche.net/contents/1147-introduction-aux-systemes-unix">son état civile est enregistré pour le 1er janvier de 1970</a> ha-ha …et dès le début le système est utilisé en interne entre par les secrétaires) Du nom de "<code>pr</code>", elle prépare la « mise en page » pour l'impression papier… (est-ce que son nom est l'abréviation de « <em>print</em> » ou le sigle de « <em>print request</em> » est une des questions qui me turlupinent…)</p>
<p>Cette mise en page va consister surtout en la « pagination » (i.e. le découpage en « page ») comme le font les éditeurs plein écran ("<code>vi</code>", "<code>emacs</code>", "<code>nano</code>", etc.) et visualiseurs de texte ("<code>pager</code>", "<code>pg</code>", "<code>more</code>", "<code>less</code>", "<code>most</code>", etc.) Sauf qu'eux raisonnent par rapport à l'écran tandis que "<code>pr</code>" raisonne par rapport à la page papier.</p>
<p>Tout comme l'écran du terminal ou de la console a un certain nombre de lignes × colonnes (par exemple 25×80) la page aussi. Ces dimensions (longueur × largeur de papier, par défaut 66×72) peuvent être spécifiées respectivement avec les options "<code>-l</code>" (pour « page length ») et "<code>-w</code>" (pour « page Width »).</p>
<p>Mais pour le papier, il y aussi la notion de « <a href="https://techlib.fr/definition/margin.html">marge interne</a> » (nulle par défaut, et à ne pas confondre avec la <a href="https://forum.ubuntu-fr.org/viewtopic.php?id=1105761">marge technique</a> ou le <a href="https://www.coollibri.com/blog/utilite-dune-impression-sans-marge-sous-word/">débord</a> qui s'ajoute), qui est retiré de la largeur, avec l'option "<code>-o</code>" (pour « line Offset »)<br><br>
<img src="//img.linuxfr.org/img/68747470733a2f2f7777772e636f6f6c6c696272692e636f6d2f626c6f672f77702d636f6e74656e742f75706c6f6164732f323031382f31322f696d7072696d65722d6368657a2d756e2d70726f66657373696f6e6e656c2d6d61726765732d65742d666f6e64732d7065726475732d31303234783733312e6a7067/imprimer-chez-un-professionnel-marges-et-fonds-perdus-1024x731.jpg" alt="" title="Source : https://www.coollibri.com/blog/wp-content/uploads/2018/12/imprimer-chez-un-professionnel-marges-et-fonds-perdus-1024x731.jpg"><br>
Comme il s'agit de document à imprimer, "<code>pr</code>" rajoute un <a href="https://www.linternaute.fr/dictionnaire/fr/definition/en-tete/">en-tête</a> de 5 lignes (prises dans la longueur totale…) et y place au milieu (troisième ligne) : la date de génération (à gauche), le numéro de page (à droite), et le nom du fichier (au milieu) ou titre du document… Il prend également 5 lignes pour le <a href="https://www.linternaute.fr/dictionnaire/fr/definition/pied-de-page/">pied de page</a>…</p>
<p>Ce n'est certainement pas parfait, mais <a href="https://www.developpez.net/forums/d2060606/logiciels/microsoft-office/word/ajouter-marges-lorsqu-y-entete-pied-page/">moins prise de tête àmha.</a></p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># noter la belle entête faite toute seule</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -w <span class="m">50</span> <span class="p">|</span> head
<span class="go">2017-10-30 13:27 Page 1</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># ajouter un décalage de 2 espaces à gauche</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -o <span class="m">2</span> -w <span class="m">50</span> <span class="p">|</span> head
<span class="go"> 2017-10-30 13:33 Page 1</span>
<span class="go"> Fournitures Quantité Prix</span>
<span class="go"> Crayons 12 15,76</span>
<span class="go"> Feuilles A4 1000 137,5</span>
<span class="go"> Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># pr mange 5 lignes en haut et autant en bas</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -l <span class="m">12</span> -w <span class="m">50</span> <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:43 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9</span>
<span class="go"> 10</span>
<span class="go"> 11</span>
<span class="go"> 12</span>
<span class="go"> 13</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 15</span>
<span class="go"> 16 2017-10-30 13:43 Page 2</span>
<span class="go"> 17</span>
<span class="go"> 18</span>
<span class="go"> 19 Correcteurs 10 18</span>
<span class="go"> 20</span>
<span class="go"> 21</span>
<span class="go"> 22</span>
<span class="go"> 23</span>
<span class="go"> 24</span>
<span class="gp">$</span> <span class="c1"># pr mange 10 lignes et pagine automatiquement</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -l <span class="m">13</span> -w <span class="m">50</span> <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:43 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9</span>
<span class="go"> 10</span>
<span class="go"> 11</span>
<span class="go"> 12</span>
<span class="go"> 13</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 15</span>
<span class="go"> 16 2017-10-30 13:43 Page 2</span>
<span class="go"> 17</span>
<span class="go"> 18</span>
<span class="go"> 19 Correcteurs 10 18</span>
<span class="go"> 20</span>
<span class="go"> 21</span>
<span class="go"> 22</span>
<span class="go"> 23</span>
<span class="go"> 24</span>
<span class="go"> 25</span>
<span class="go"> 26</span></code></pre>
<p>Le pied de page n'est pas utilisé et je trouve que c'est un gâchis ces cinq lignes. Mais c'est très utile pour les sociétés, qui impriment sur du papier avec <a href="http://dircomleblog.canalblog.com/archives/2009/11/27/15907065.html">un certain nombre de mentions</a> qui sont <a href="https://www.entreprises.cci-paris-idf.fr/web/reglementation/developpement-entreprise/droit-affaires/quelles-sont-mentions-obligatoires-documents-commerciaux">plus ou moins obligatoires</a> dans cette zone… On en rencontre qui utilisent l'en-tête du document pour des informations autre que leur logo et leur nom.</p>
<p>L'option "<code>-t</code>" permet de désactiver les en-têtes et pieds de page ajoutés automatiquement, comme souvent requis sur les sorties papier. Noter que ceux-ci sont automatiquement désactivés quand le nombre de lignes n'est pas supérieur à dix !</p>
<p>Question : Est-ce que les commandes déjà évoquées sont utiles ici ?<br><br>
Réponse : Oui, "<code>-w</code>" positionne le numéro de page sans adapter le texte, et la largeur minimale utilisée est de 24 (en dessous pas pris en compte.)<br><br>
L'implémentation GNU offre en plus l'option "<code>-W</code>" qui permet d'appliquer un effet « <em>truncate</em> »… Cette implémentation offre également l'option "<code>-T</code>" qui fait comme "<code>-t</code>" mais envoie le code de saut saut de page au lieu de plusieurs saut de ligne : c'est normalement plus rapide car l'imprimante éjecte la page au lieu de la dérouler ligne par ligne. Il est à noter que la norme propose "<code>-F</code>" et "<code>-f</code>" pour ce faire (donc "<code>-T</code>" a pour forme portable "<code>-tF</code>" simplement.)</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># plus d'entête et pied de page avec "`-t`"</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -t <span class="p">|</span> head
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># plus d'entête et pied de page quand l<=10</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -l <span class="m">5</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># "-w" ne tronque pas (utile ici)</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -w <span class="m">26</span> <span class="p">|</span> head
<span class="go">2017-10-30 13:27 Page 1</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># "-w" ne s'applique pas au text</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"ceci est une ligne de 30 car."</span> <span class="p">|</span> pr -l <span class="m">2</span> -w <span class="m">20</span>
<span class="go">ceci est une ligne de 30 car.</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"ceci est une ligne de 30 car."</span> <span class="p">|</span> pr -l <span class="m">2</span> -W <span class="m">20</span>
<span class="go">ceci est une ligne d</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"ceci est une ligne de 30 car."</span> <span class="p">|</span> fold -s -w <span class="m">20</span> <span class="p">|</span> pr -l <span class="m">2</span> -w <span class="m">20</span>
<span class="go">ceci est une ligne</span>
<span class="go">de 30 car.</span>
<span class="gp">$</span> <span class="c1"># "-w" utilise une valeur minimale de 24...</span>
<span class="gp">$</span> <span class="c1"># (juste ce qu'il faut pour l'horodatage et la pagination)</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -w <span class="m">10</span> <span class="p">|</span> head
<span class="go">2017-10-30 13:27 Page 1</span>
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># "-F" si on ne veut pas enregistrer dans un fichier</span>
<span class="gp">$</span> <span class="c1"># mais envoyer directement à l'imprimante</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -w <span class="m">10</span> <span class="p">|</span> wc
<span class="go"> 66 17 196</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquets.txt <span class="p">|</span> pr -w <span class="m">10</span> -F <span class="p">|</span> wc
<span class="go"> 9 17 140</span></code></pre>
<p>On ne le voit pas dans les précédents exemples, mais dans l'entête il y a le nom du fichier centré. Du moins, par défaut, car on peut mettre un texte personnalisé en utilisant l'option "<code>-h</code>" (pour « <em>personalized Header</em> »)</p>
<p>L'implémentation GNU propose en plus l'option "<code>-D</code>" pour personnaliser le champ de date par son propre texte… (on peut bien entendu utiliser "<code>$(date +...)</code>" pour changer le format de la date si on le désire.)</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># préparons notre fichier...</span>
<span class="gp">$</span> expand -t <span class="m">13</span>,23 taquet.txt > formated1
<span class="gp">$</span> <span class="c1"># faisons notre impression</span>
<span class="gp">$</span> pr -w <span class="m">40</span> -l <span class="m">15</span> formated1 <span class="p">|</span> head <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:45 formated1 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9 Correcteurs 10 18</span>
<span class="go"> 10</span>
<span class="gp">$</span> <span class="c1"># changeons le titre tant qu'à faire</span>
<span class="gp">$</span> pr -w <span class="m">40</span> -l <span class="m">15</span> -h <span class="s2">"liste d'achats"</span> formated1 <span class="p">|</span> head <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:47 liste d'achats Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9 Correcteurs 10 18</span>
<span class="go"> 10</span>
<span class="gp">$</span> <span class="c1"># vérifions pour la largeur minimale...</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -h <span class="s2">"liste d'achats"</span> formated1 <span class="p">|</span> head <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:47 liste d'achats Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9 Correcteurs 10 18</span>
<span class="go"> 10</span>
<span class="gp">$</span> <span class="c1"># changeons le champ de date aussi...</span>
<span class="gp">$</span> pr -w <span class="m">20</span> -l <span class="m">15</span> -h <span class="s2">"liste d'achats"</span> -D <span class="s2">"now"</span> formated1 <span class="p">|</span> head <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 now liste d'achats Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9 Correcteurs 10 18</span>
<span class="go"> 10</span>
<span class="gp">$</span> <span class="c1"># gardons juste la date</span>
<span class="gp">$</span> <span class="c1"># (obligatoire sinon utiliser cat au lieu de pr)</span>
<span class="gp">$</span> pr -w <span class="m">20</span> -l <span class="m">15</span> -h <span class="s2">""</span> -D <span class="s2">""</span> formated1 <span class="p">|</span> head <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix</span>
<span class="go"> 7 Crayons 12 15,76</span>
<span class="go"> 8 Feuilles A4 1000 137,5</span>
<span class="go"> 9 Correcteurs 10 18</span>
<span class="go"> 10</span></code></pre>
<p>On voit au passage, que la largeur minimale n'est pas 24 mais <code>(10+1+5)+1+N+1+(4+1+1) = 17+N+7</code> avec :</p>
<ul>
<li>champ de gauche : <code>10+1+5</code> est le nombre de caractères pour la date (<code>10</code>) et l'horaire (<code>5</code>) conformément aux <a href="http://www.btb.termiumplus.gc.ca/tpv2guides/guides/clefsfp/index-fra.html?lang=fra&lettr=indx_catlog_d&page=9lcOojjUrxt8.html#date-chif">normes</a>
</li>
<li>champ de droite : <code>4+1+1</code> est le nombre de caractères pour le numéro de page (<code><10</code> sinon augmenter en conséquence)</li>
<li>champ du milieu : <code>N</code> est le nombre de caractères composant le titre</li>
</ul>
<p>On n'a certes pas le choix pour l'emplacement des différents éléments, mais cela correspond bien aux pratiques en vigueur que l'on bafoue avec les traitement de texte en s'improvisant typographe.</p>
<p>C'est beau n'est-ce pas ? Mais cette commande peut faire plus !<br>
Dans notre exemple, il peut être intéressant de numéroter les lignes du tableau, et il sait le faire avec l'option "<code>-n</code>" ; pas besoin de passer par "<a href="https://pubs.opengroup.org/onlinepubs/9699919799/utilities/nl.html"><code>nl</code></a>" au préalable (mais ce filtre a ses petits plus…)<br>
Par défaut, elle utilise une colonne de 5 caractères, mais on peut ajuster cela en accolant un entier à l'option.<br><br>
Le contenu est séparé du numéro par une tabulation, ce qui le fait commencer en huitième colonne. On peut aussi changer ce caractère par un autre accolé à l'option. </p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># numéroter les lignes du tableau</span>
<span class="gp">$</span> pr -n -l <span class="m">5</span> formated1
<span class="go"> 1 Fournitures Quantité Prix</span>
<span class="go"> 2 Crayons 12 15,76</span>
<span class="go"> 3 Feuilles A4 1000 137,5</span>
<span class="go"> 4 Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># numéroter sur 3 colonnes</span>
<span class="gp">$</span> pr -n3 -l <span class="m">5</span> formated1
<span class="go"> 1 Fournitures Quantité Prix</span>
<span class="go"> 2 Crayons 12 15,76</span>
<span class="go"> 3 Feuilles A4 1000 137,5</span>
<span class="go"> 4 Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># il faut acoller l'argument...</span>
<span class="gp">$</span> pr -n <span class="m">3</span> -l <span class="m">5</span> formated1
<span class="go">pr: 3: No such file or directory</span>
<span class="go"> 1 Fournitures Quantité Prix</span>
<span class="go"> 2 Crayons 12 15,76</span>
<span class="go"> 3 Feuilles A4 1000 137,5</span>
<span class="go"> 4 Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># utiliser le point au lieu de la tabulation</span>
<span class="gp">$</span> pr -n. -l <span class="m">5</span> formated1
<span class="go"> 1.Fournitures Quantité Prix</span>
<span class="go"> 2.Crayons 12 15,76</span>
<span class="go"> 3.Feuilles A4 1000 137,5</span>
<span class="go"> 4.Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># utiliser l'espace au lieu de la tabulation</span>
<span class="gp">$</span> pr -n<span class="se">\ </span> -l <span class="m">5</span> formated1
<span class="go"> 1 Fournitures Quantité Prix</span>
<span class="go"> 2 Crayons 12 15,76</span>
<span class="go"> 3 Feuilles A4 1000 137,5</span>
<span class="go"> 4 Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># toujours le point et sur deux colonnes</span>
<span class="gp">$</span> pr -n.2 -t -l <span class="m">5</span> formated1
<span class="go"> 1.Fournitures Quantité Prix</span>
<span class="go"> 2.Crayons 12 15,76</span>
<span class="go"> 3.Feuilles A4 1000 137,5</span>
<span class="go"> 4.Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># l'ordre importe ici...</span>
<span class="gp">$</span> pr -n3. -t -l <span class="m">5</span> formated1
<span class="go">pr: `-n' extra characters or invalid number in argument: `3.'</span>
<span class="go">Try `pr --help' for more information</span></code></pre>
<p>Il peut, de la même façon convertir des espaces successifs en un seul caractère (par défaut la tabulation, comme "<code>unexpand</code>"), avec l'option "<code>-i</code>" et son corolaire avec (par défaut la tabulation en espaces, comme "<code>expand</code>") avec l'option "<code>-e</code>". Ces deux options s'utilisent comme "<code>-n</code>" : il y a des paramètres par défaut (espace/tabulation et huit) mais on peut indiquer son caractère et son nombre (de blanc ou espacement des taquets.)</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># quand il y a plus de 2 espaces remplacer par 1 tab</span>
<span class="gp">$</span> <span class="c1"># taquet en position muliple de 8 (8, 16, 24, 32, etc.)</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"Quatre Trois Deux Un Zero"</span> <span class="p">|</span> pr -l <span class="m">1</span> -i <span class="p">|</span> cat -t
<span class="go">Quatre^I Trois^I Deux^IUn Zero</span>
<span class="gp">$</span> <span class="c1"># quand il y a plus de 2 espaces remplacer par 1 tab</span>
<span class="gp">$</span> <span class="c1"># taquet en position muliple de 2 (2, 4, 6, 8, 10, 12, etc.)</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"Quatre Trois Deux Un Zero"</span> <span class="p">|</span> pr -l <span class="m">1</span> -i2 <span class="p">|</span> cat -t
<span class="go">Quatre^I^ITrois^I^IDeux^IUn Zero</span>
<span class="gp">$</span> <span class="c1"># quand il y a plus de 2 espaces remplacer par 1 tab</span>
<span class="gp">$</span> <span class="c1"># taquet en position muliple de 12 (12, 24, 32, 64, etc.)</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"Quatre Trois Deux Un Zero"</span> <span class="p">|</span> pr -l <span class="m">1</span> -i2 <span class="p">|</span> cat -t
<span class="go">Quatre Trois Deux^IUn Zero</span>
<span class="gp">$</span> <span class="c1"># quand il y a plus de 2 espaces remplacer par 1 point</span>
<span class="gp">$</span> <span class="c1"># taquet en position muliple de 8 (8, 16, 24, 32, etc.)</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"Quatre Trois Deux Un Zero"</span> <span class="p">|</span> pr -l <span class="m">1</span> -i. <span class="p">|</span> cat -t
<span class="go">Quatre. Trois. Deux.Un Zero</span>
<span class="gp">$</span> <span class="c1"># quand il y a plus de 2 espaces remplacer par 1 point</span>
<span class="gp">$</span> <span class="c1"># taquet en position muliple de 6 (6, 12, 18, 24, etc.)</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"Quatre Trois Deux Un Zero"</span> <span class="p">|</span> pr -l <span class="m">1</span> -i.6 <span class="p">|</span> cat -t
<span class="go">Quatre Trois.Deux.Un Zero</span>
<span class="gp">$</span> <span class="c1"># chez moi, Ctrl+V puis Tab, sinon utiliser un fichier</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"tab tabtab stop"</span> <span class="p">|</span> cat -t
<span class="go">tab^Itabtab^I^Istop</span>
<span class="gp">$</span> <span class="c1"># remplacer les tabulations par 4 espaces</span>
<span class="gp">$</span> <span class="c1"># en fait on positionne aux taquets multiples de 8...</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"tab tabtab stop"</span> <span class="p">|</span> pr -l <span class="m">1</span> -e <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">tab~~~~~tabtab~~~~~~~~stop</span>
<span class="gp">$</span> <span class="c1"># remplacer les tabulations par 3 espaces</span>
<span class="gp">$</span> <span class="c1"># en fait on positionne aux taquets multiples de 3...</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"tab tabtab stop"</span> <span class="p">|</span> pr -l <span class="m">1</span> -e3 <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">tab~~~tabtab~~~~~~stop</span>
<span class="gp">$</span> <span class="c1"># remplacer les underscores par 3 espaces</span>
<span class="gp">$</span> <span class="c1"># en fait on positionne aux taquets multiples de 3...</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"tab_tabtab__stop"</span> <span class="p">|</span> pr -l <span class="m">1</span> -e_3 <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">tab~~~tabtab~~~~~~stop</span>
<span class="gp">$</span> <span class="c1"># remplacer les underscores par 4 espaces</span>
<span class="gp">$</span> <span class="c1"># en fait on positionne aux taquets multiples de 8...</span>
<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">"tab_tabtab__stop"</span> <span class="p">|</span> pr -l <span class="m">1</span> -e_ <span class="p">|</span> tr <span class="s1">' '</span> <span class="s1">'~'</span>
<span class="go">tab~~~~~tabtab~~~~~~~~stop</span></code></pre>
<p>Il y a peu de cas où cela sert vraiment, d'après mon expérience, mais la possibilité existe ; et je n'ai pas pu retrouver la cause historique.</p>
<h2 id="toc-impressions-en-rang-etou-partielles">impressions en rang et/ou partielles</h2>
<p>Une des possibilités incontournables est le multi colonage ! Les lignes du texte qui est passé à la commande, sont divisées en autant de colonnes que demandées par l'option numérique (qui est donc "<code>-1</code>" par défaut, et on utilisera "<code>-2</code>" pour faire une double colonne et "<code>-3</code>" pour une triple, etc.), puis ces colonnes sont juxtaposées horizontalement (comme avec "<a href="https://pubs.opengroup.org/onlinepubs/9699919799/utilities/paste.html"><code>paste</code></a>" ou "<a href="https://manpagez.com/man/1/rs/"><code>rs</code></a>" par exemple.)<br>
Le séparateur entre colonnes est l'espace, que l'on peut changer avec l'option "<code>-s</code>" auquel on accole le caractère voulu (mais contrairement au "<code>-d</code>" de "<code>paste</code>" on ne peut pas alterner plusieurs séparateurs)<br>
L'implémentation GNU propose l'option "<code>-S</code>" qui ici ne change rien… (tout comme "<code>-W</code>" ne change rien dans le cas présent) on y reviendra.</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># GNU/Linux: quelle est la plus longue ligne?</span>
<span class="gp">$</span> <span class="c1"># et on voit qu'une largeur de 30 convient</span>
<span class="gp">$</span> wc -L formated1
<span class="go">28 formated1</span>
<span class="gp">$</span> <span class="c1"># cat formated1</span>
<span class="gp">$</span> pr -l <span class="m">4</span> -w <span class="m">30</span> formated1
<span class="go">Fournitures Quantité Prix</span>
<span class="go">Crayons 12 15,76</span>
<span class="go">Feuilles A4 1000 137,5</span>
<span class="go">Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># sur 2 colonnes de 30/2</span>
<span class="gp">$</span> <span class="c1"># lignes "Fourn..." et "Crayo..." d'une part</span>
<span class="gp">$</span> <span class="c1"># lignes "Feuil..." et "Corre..." d'autre part</span>
<span class="gp">$</span> pr -2 -l <span class="m">4</span> -w <span class="m">30</span> formated1
<span class="go">Fournitures Q Feuilles A4 1</span>
<span class="go">Crayons 1 Correcteurs 1</span>
<span class="gp">$</span> <span class="c1"># sur 2 colonnes de 60/2</span>
<span class="gp">$</span> <span class="c1"># lignes "Fourn..." et "Crayo..." d'une part</span>
<span class="gp">$</span> <span class="c1"># lignes "Feuil..." et "Corre..." d'autre part</span>
<span class="gp">$</span> pr -l <span class="m">4</span> -w <span class="m">60</span> -2 formated1
<span class="go">Fournitures Quantité Prix Feuilles A4 1000 137,5</span>
<span class="go">Crayons 12 5,76 Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># sur 2 colonnes de 60/2</span>
<span class="gp">$</span> <span class="c1"># avec le point au lieu d'espace</span>
<span class="gp">$</span> pr -l <span class="m">4</span> -2 -w <span class="m">60</span> -s. formated1
<span class="go">Fournitures Quantité Prix .Feuilles A4 1000 137,5</span>
<span class="go">Crayons 12 5,76 .Correcteurs 10 18</span>
<span class="gp">$</span> <span class="c1"># attention à bien le coller...</span>
<span class="gp">$</span> pr -l <span class="m">4</span> -2 -w <span class="m">60</span> -s . formated1
<span class="go">pr: .: Is a directory</span>
<span class="gp">$</span> <span class="c1"># sur 2 colonnes de 30/2</span>
<span class="gp">$</span> <span class="c1"># avec rien au lieu d'espace</span>
<span class="gp">$</span> pr -l <span class="m">4</span> -2 -w <span class="m">30</span> -s formated1
<span class="go">Fournitures QuFeuilles A4 1</span>
<span class="go">Crayons 12Correcteurs 1</span>
<span class="gp">$</span> <span class="c1"># sur 2 colonnes de 30/2</span>
<span class="gp">$</span> <span class="c1"># avec point au lieu d'espace</span>
<span class="gp">$</span> <span class="c1"># et en numérotant (on voit la répartition des lignes)</span>
<span class="gp">$</span> pr -l <span class="m">4</span> -2 -w <span class="m">30</span> -s. -n formated1
<span class="go"> 1 Fourni. 3 Feuill</span>
<span class="go"> 2 Crayon. 4 12Corr</span></code></pre>
<p>J'avoue que cet exemple n'est pas le mieux, mais ça montre toute la difficulté de la chose et la nécessité d'avoir une commande dédiée pour « mettre en page » avant d'imprimer. Prenons un autre exemple, qui va nous permettre de mettre en évidence l'option "<code>-a</code>" (change le sens de colonage) qui peut être utile dans certains rares cas :</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># préparons notre fichier...</span>
<span class="gp">$</span> <span class="c1"># pour être à 28 comme formated1</span>
<span class="gp">$</span> fold -s -w <span class="m">28</span> wrap.txt > formated0
<span class="gp">$</span> <span class="c1"># imprimons en 2 colonnes de 60/2</span>
<span class="gp">$</span> <span class="c1"># remplissage normal, en N par page: P1C1, P1C2, P2C1, P2C2</span>
<span class="gp">$</span> pr -2 -w <span class="m">60</span> -l <span class="m">15</span> -f formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-11-01 13:05 formated0 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a column position (or bytes.</span>
<span class="go"> 7 filter that shall fold if the *-b* option is</span>
<span class="go"> 8 lines from its input files, espicified).</span>
<span class="go"> 9 but breaking the lines to Use *-* option to split at</span>
<span class="go"> 10 have a maximum of _width_ latest space before maximum</span>
<span class="go"> 11 ^L</span>
<span class="go"> 12</span>
<span class="go"> 13 2017-11-01 13:05 formated0 Page 2</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16 _width_. input files, but break the</span>
<span class="go"> 17 lines to have a maximum of</span>
<span class="go"> 18 The _fmt_ utility is a _width_ column position.</span>
<span class="go"> 19 filter that shall reformat</span>
<span class="go"> 20 each paragraph from its</span>
<span class="go"> 21 ^L</span>
<span class="gp">$</span> <span class="c1"># imprimons en 2 colonnes de 60/2</span>
<span class="gp">$</span> <span class="c1"># remplissage alternatif, en Z par lignes successives...</span>
<span class="gp">$</span> pr -2 -w <span class="m">60</span> -l <span class="m">15</span> -f formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-11-01 13:05 formated0 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a filter that shall fold</span>
<span class="go"> 7 lines from its input files, but breaking the lines to</span>
<span class="go"> 8 have a maximum of _width_ column position (or bytes,</span>
<span class="go"> 9 if the *-b* option is specified).</span>
<span class="go"> 10 Use *-s* option to split at latest space before maximum</span>
<span class="go"> 11 ^L</span>
<span class="go"> 12</span>
<span class="go"> 13 2017-11-01 13:05 formated0 Page 2</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16 _width_.</span>
<span class="go"> 17 The _fmt_ utility is a filter that shall reformat</span>
<span class="go"> 18 each paragraph from its input files, but break the</span>
<span class="go"> 29 lines to have a maximum of _width_ column position.</span>
<span class="go"> 20</span>
<span class="go"> 21 ^L</span>
<span class="gp">$</span> <span class="c1"># imprimons en 2 colonnes de 60/2</span>
<span class="gp">$</span> <span class="c1"># remplissage alternatif, en Z par lignes successives...</span>
<span class="gp">$</span> pr -2 -w <span class="m">60</span> -l <span class="m">12</span> -f formated1 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-11-01 13:09 formated1 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 Fournitures Quantité Prix Crayons 12 15,75</span>
<span class="go"> 7 Feuilles A4 10000 137,5 Correcteurs 10 18</span>
<span class="go"> 8 ^L</span></code></pre>
<p>Je n'ai eu à utiliser ce truc qu'une seule fois, pour imprimer un index de noms (à raison d'un par ligne dans le fichier) triés (par "<code>sort</code>")<br>
Il y a aussi l'option "<code>-d</code>", sans paramètre, que j'invite à tester.</p>
<p>Il y une autre option un peu étrange qu'il peut être utile de connaître : "+" qui permet de commencer à partir d'une page donnée… L'implémentation GNU permet permet en plus d'indiquer une s'arrêter à une page donnée…<br>
Avec cette option, l'implémentation GNU propose une option "<code>-N</code>" pour réinitialiser le compteur quand on utilise l'option "<code>-n</code>" et c'est pas mal.</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># par défaut, toutes les 4 pages</span>
<span class="gp">$</span> <span class="c1"># (de la première à la dernière donc)</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 formated0 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a</span>
<span class="go"> 7 filter that shall fold</span>
<span class="go"> 8 lines from its input files,</span>
<span class="go"> 9 but breaking the lines to</span>
<span class="go"> 10 have a maximum of _width_</span>
<span class="go"> 11 ^L</span>
<span class="go"> 12</span>
<span class="go"> 13 2017-10-30 13:54 formated0 Page 2</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16 column position (or bytes,</span>
<span class="go"> 17 if the *-b* option is</span>
<span class="go"> 18 specified).</span>
<span class="go"> 19 Use *-s* option to split at</span>
<span class="go"> 20 latest space before maximum</span>
<span class="go"> 21 ^L</span>
<span class="go"> 22</span>
<span class="go"> 23 2017-10-30 13:54 formated0 Page 3</span>
<span class="go"> 24</span>
<span class="go"> 25</span>
<span class="go"> 26 _width_.</span>
<span class="go"> 27</span>
<span class="go"> 28 The _fmt_ utility is a</span>
<span class="go"> 29 filter that shall reformat</span>
<span class="go"> 30 each paragraph from its</span>
<span class="go"> 31 ^L</span>
<span class="go"> 32</span>
<span class="go"> 33 2017-10-30 13:54 formated0 Page 4</span>
<span class="go"> 34</span>
<span class="go"> 35</span>
<span class="go"> 36 input files, but break the</span>
<span class="go"> 37 lines to have a maximum of</span>
<span class="go"> 38 _width column position.</span>
<span class="go"> 39</span>
<span class="go"> 40</span>
<span class="go"> 41 ^L</span>
<span class="gp">$</span> <span class="c1"># possible seulement à partir de la 3ème...</span>
<span class="gp">$</span> <span class="c1"># (de la 3ème à la dernière page donc)</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f +3 formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 formated0 Page 3</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 _width_.</span>
<span class="go"> 7</span>
<span class="go"> 8 The _fmt_ utility is a</span>
<span class="go"> 9 filter that shall reformat</span>
<span class="go"> 10 each paragraph from its</span>
<span class="go"> 11 ^L</span>
<span class="go"> 12</span>
<span class="go"> 13 2017-10-30 13:54 formated0 Page 4</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16 input files, but break the</span>
<span class="go"> 17 lines to have a maximum of</span>
<span class="go"> 18 _width column position.</span>
<span class="go"> 19</span>
<span class="go"> 20</span>
<span class="go"> 21 ^L</span>
<span class="gp">$</span> <span class="c1"># il n'y a pas de 5ème page...!</span>
<span class="gp">$</span> <span class="c1"># (j'utilise l'astuce avec 999</span>
<span class="gp">$</span> <span class="c1"># pour avoir le nombre de pages)</span>
<span class="gp">$</span> pr -w <span class="m">40</span> -l <span class="m">17</span> +5 formated0
<span class="go">pr: starting page number 5 exceeds page count 4</span>
<span class="gp">$</span> <span class="c1"># GNU pr permet de la 2ème à la 3ème...</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f +2:3 formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 formated0 Page 2</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 column position (or bytes,</span>
<span class="go"> 7 if the *-b* option is</span>
<span class="go"> 8 specified).</span>
<span class="go"> 9 Use *-s* option to split at</span>
<span class="go"> 10 latest space before maximum</span>
<span class="go"> 11 ^L</span>
<span class="go"> 12</span>
<span class="go"> 13 2017-10-30 13:54 formated0 Page 3</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16 _width_.</span>
<span class="go"> 17</span>
<span class="go"> 18 The _fmt_ utility is a</span>
<span class="go"> 19 filter that shall reformat</span>
<span class="go"> 20 each paragraph from its</span>
<span class="go"> 21 ^L</span>
<span class="gp">$</span> <span class="c1"># GNU pr permet juste la 3ème...</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f +3:3 formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 formated0 Page 3</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 _width_.</span>
<span class="go"> 7</span>
<span class="go"> 8 The _fmt_ utility is a</span>
<span class="go"> 9 filter that shall reformat</span>
<span class="go"> 10 each paragraph from its</span>
<span class="go"> 11 ^L</span>
<span class="gp">$</span> <span class="c1"># pour juste les 2 premières bien indiquer 1:2</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f +:2 formated0
<span class="go">pr: invalid + argument `:2'</span>
<span class="gp">$</span> <span class="c1"># quand on numérote la page 4</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f +4 -n formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 formated0 Page 4</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 16 input files, but break the</span>
<span class="go"> 7 17 lines to have a maximum of</span>
<span class="go"> 8 18 _width column position.</span>
<span class="go"> 9 19</span>
<span class="go"> 10 20</span>
<span class="go"> 11 ^L</span>
<span class="gp">$</span> <span class="c1"># GNU nous permet de dire qu'on commence</span>
<span class="gp">$</span> <span class="c1"># à la 4ème ligne (du second paragraphe)</span>
<span class="gp">$</span> pr -w <span class="m">30</span> -l <span class="m">15</span> -f +4 -n -N <span class="m">4</span> formated0 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 formated0 Page 4</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 4 input files, but break the</span>
<span class="go"> 7 5 lines to have a maximum of</span>
<span class="go"> 8 6 _width column position.</span>
<span class="go"> 9 7</span>
<span class="go"> 10 8</span>
<span class="go"> 11 ^L</span></code></pre>
<p>On remarque au passage (première ligne du texte ou sixième imprimée, à la troisième page) que "<code>pr</code>" ne connait pas la notion de paragraphes, ou en tout cas ne gère pas le difficile <a href="http://www.encyclopedia-bureautique.com/dictionnaire/les-veuves-orphelines">problème de veuvage et d'orphelinage des lignes</a> (lignes creuses/isolées/désolidarisées.)</p>
<h2 id="toc-impressions-de-livrets">impressions de livrets</h2>
<p>Tout comme "<code>fold</code>" et "<code>fmt</code>", "<code>pr</code>" peut prendre plusieurs fichiers en entrée. Sans l'utilisation de l'option "<code>-h</code>" chaque fichier se voit indiqué car les fichiers sont parcourus <em>séquentiellement</em> de sorte que chacun commence sur une nouvelle page. Mieux, les fichiers suivants commencent toujours sur une page impaire (c'est pratique quand chaque fichier représente un chapitre de votre manuscrit par exemple) ce qui est <em>top</em> ! Par contre, il recommence la pagination (ce qui est pratique si on imprime des documents séparés mais pas génial si on imprime un livre éclaté en plusieurs fichiers) et peut produire des pages vides (l'algorithme est relativement simple et correspond à la plupart des cas courants.) En tout cas, tout cela est fait automatiquement…</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># préparons notre fichier...</span>
<span class="gp">$</span> fold -w <span class="m">40</span> -s wrap.txt > formated2
<span class="gp">$</span> <span class="c1"># faisons notre impression 1 colonne</span>
<span class="gp">$</span> <span class="c1"># c'est séquentiel, normal.</span>
<span class="gp">$</span> pr -w <span class="m">40</span> -l <span class="m">17</span> formated2 formated1 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:45 formated2 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a filter that</span>
<span class="go"> 7 shall fold lines from its input files,</span>
<span class="go"> 8 but breaking the lines to have a</span>
<span class="go"> 9 maximum of~ width ~column position (or</span>
<span class="go"> 10 bytes, if the *-b* option is specified)</span>
<span class="go"> 11 Use *-s* option to split at latest</span>
<span class="go"> 12 space before maximum _width_.</span>
<span class="go"> 13</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16</span>
<span class="go"> 17</span>
<span class="go"> 18</span>
<span class="go"> 19</span>
<span class="go"> 20 2017-10-30 13:45 formated2 Page 2</span>
<span class="go"> 21</span>
<span class="go"> 22</span>
<span class="go"> 23</span>
<span class="go"> 24 The _fmt_ utility is a filter that</span>
<span class="go"> 25 shall reformat each paragraph from its</span>
<span class="go"> 26 input files, but break the lines to</span>
<span class="go"> 27 have a maximum of _width_ column</span>
<span class="go"> 28 position.</span>
<span class="go"> 29</span>
<span class="go"> 30</span>
<span class="go"> 31</span>
<span class="go"> 32</span>
<span class="go"> 33</span>
<span class="go"> 34</span>
<span class="go"> 35</span>
<span class="go"> 36</span>
<span class="go"> 37 2017-10-30 13:45 formated2 Page 3</span>
<span class="go"> 38</span>
<span class="go"> 39</span>
<span class="go"> 40</span>
<span class="go"> 41</span>
<span class="go"> 42</span>
<span class="go"> 43</span>
<span class="go"> 44</span>
<span class="go"> 45</span>
<span class="go"> 46</span>
<span class="go"> 47</span>
<span class="go"> 48</span>
<span class="go"> 49</span>
<span class="go"> 50</span>
<span class="go"> 51</span>
<span class="go"> 52</span>
<span class="go"> 53</span>
<span class="go"> 54 2017-10-30 13:45 formated1 Page 1</span>
<span class="go"> 55</span>
<span class="go"> 56</span>
<span class="go"> 57 Fournitures Quantité Prix</span>
<span class="go"> 58 Crayons 12 15,76</span>
<span class="go"> 59 Feuilles A4 1000 137,5</span>
<span class="go"> 60 Correcteurs 10 18</span>
<span class="go"> 61</span>
<span class="go"> 62</span>
<span class="go"> 63</span>
<span class="go"> 64</span>
<span class="go"> 65</span>
<span class="go"> 66</span>
<span class="gp">$</span> pr -w <span class="m">40</span> -l <span class="m">17</span> -f formated2 formated1 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:47 formated2 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a filter that</span>
<span class="go"> 7 shall fold lines from its input files,</span>
<span class="go"> 8 but breaking the lines to have a</span>
<span class="go"> 9 maximum of~ width ~column position (or</span>
<span class="go"> 10 bytes, if the *-b* option is specified)</span>
<span class="go"> 11 Use *-s* option to split at latest</span>
<span class="go"> 12 space before maximum _width_.</span>
<span class="go"> 13 ^L</span>
<span class="go"> 14</span>
<span class="go"> 15 2017-10-30 13:47 formated2 Page 2</span>
<span class="go"> 16</span>
<span class="go"> 17</span>
<span class="go"> 18</span>
<span class="go"> 19 The _fmt_ utility is a filter that</span>
<span class="go"> 20 shall reformat each paragraph from its</span>
<span class="go"> 21 input files, but break the lines to</span>
<span class="go"> 22 have a maximum of _width_ column</span>
<span class="go"> 23 position.</span>
<span class="go"> 24</span>
<span class="go"> 25 ^L</span>
<span class="go"> 26</span>
<span class="go"> 27 2017-10-30 13:47 formated2 Page 3</span>
<span class="go"> 28</span>
<span class="go"> 29</span>
<span class="go"> 30</span>
<span class="go"> 31 ^L</span>
<span class="go"> 32</span>
<span class="go"> 33 2017-10-30 13:47 formated1 Page 1</span>
<span class="go"> 34</span>
<span class="go"> 35</span>
<span class="go"> 36 Fournitures Quantité Prix</span>
<span class="go"> 37 Crayons 12 15,76</span>
<span class="go"> 38 Feuilles A4 1000 137,5</span>
<span class="go"> 39 Correcteurs 10 18</span>
<span class="go"> 40 ^L</span>
<span class="gp">$</span> <span class="c1"># il n'y a pas de 4ème page...</span>
<span class="gp">$</span> pr -w <span class="m">40</span> -l <span class="m">17</span> +4 formated1 formated2
<span class="go">pr: starting page number 4 exceeds page count 1</span>
<span class="go">pr: starting page number 4 exceeds page count 3</span>
<span class="gp">$</span> <span class="c1"># faisons notre impression 2 colonnes</span>
<span class="gp">$</span> <span class="c1"># c'est toujours séquentiel.</span>
<span class="gp">$</span> pr -w <span class="m">60</span> -l <span class="m">17</span> -2 formated0 formated1 <span class="p">|</span> cat -n</code></pre>
<p>Il y a cependant une option sympathique quand on imprime plusieurs fichiers : "<code>-m</code>" qui va faire autant de colonnes que de fichiers, et c'est incompatible avec l'option de colonage.</p>
<pre><code class="console"><span class="gp">$</span> <span class="c1"># mettre côte à côte les 2 fichiers</span>
<span class="gp">$</span> pr -w <span class="m">60</span> -l <span class="m">15</span> -f -m formated0 formated1 <span class="p">|</span> head
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a Fournitures Quantité Prix</span>
<span class="go"> 7 filter that shall fold Crayons 12 15,76</span>
<span class="go"> 8 lines from its input files, Feuilles A4 10000 137,5</span>
<span class="go"> 9 but breaking the lines to Correcteurs 10 18</span>
<span class="go"> 10 have a maximum of _width_</span>
<span class="gp">$</span> <span class="c1"># mettre côte à côte les 2 fichiers</span>
<span class="gp">$</span> pr -w <span class="m">60</span> -l <span class="m">15</span> -f -m formated0 formated2 <span class="p">|</span> cat -n
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:55 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is a The _fold_ utility is a filte</span>
<span class="go"> 7 filter that shall fold shall fold lines from its inp</span>
<span class="go"> 8 lines from its input files, but breaking the lines to hav</span>
<span class="go"> 9 but breaking the lines to maximum of _width_ column pos</span>
<span class="go"> 10 have a maximum of _width_ bytes, if the *-b* option is</span>
<span class="go"> 11 ^L</span>
<span class="go"> 12</span>
<span class="go"> 13 2017-10-30 13:55 Page 2</span>
<span class="go"> 14</span>
<span class="go"> 15</span>
<span class="go"> 16 column position (or bytes, Use *-s* option to split at l</span>
<span class="go"> 17 if the *-b* option is space before maximum _width_.</span>
<span class="go"> 18 specified).</span>
<span class="go"> 19 Use *-s* option to split at The _fmt_ utility is a filter</span>
<span class="go"> 20 latest space before maximum shall reformat each paragraph</span>
<span class="go"> 21 ^L</span>
<span class="go"> 22</span>
<span class="go"> 23 2017-10-30 13:55 Page 3</span>
<span class="go"> 24</span>
<span class="go"> 25</span>
<span class="go"> 26 _width_. input files, but break the li</span>
<span class="go"> 27 have a maximum of _width_ col</span>
<span class="go"> 28 The _fmt_ utility is a position.</span>
<span class="go"> 29 filter that shall reformat</span>
<span class="go"> 30 each paragraph from its</span>
<span class="go"> 31 ^L</span>
<span class="go"> 32</span>
<span class="go"> 33 2017-10-30 13:55 Page 4</span>
<span class="go"> 34</span>
<span class="go"> 35</span>
<span class="go"> 36 input files, but break the</span>
<span class="go"> 37 lines to have a maximum of</span>
<span class="go"> 38 _width column position.</span>
<span class="go"> 39</span>
<span class="go"> 40</span>
<span class="go"> 41 ^L</span>
<span class="gp">$</span> <span class="c1"># mettre côte à côte les 3 fichiers</span>
<span class="gp">$</span> pr -w <span class="m">70</span> -l <span class="m">15</span> -m formated0 formated1 formated2 <span class="p">|</span> head
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:54 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is Fournitures Quantité P The _fold_ utility is</span>
<span class="go"> 7 filter that shall fold Crayons 12 shall fold lines from</span>
<span class="go"> 8 lines from its input f Feuilles A4 10000 but breaking the lines</span>
<span class="go"> 9 but breaking the lines Correcteurs 10 maximum of _width_ col</span>
<span class="go"> 10 have a maximum of _wid bytes, if the *-b* opt</span>
<span class="gp">$</span> <span class="c1"># ce n'est pas compatible avec le colonnage forcé...</span>
<span class="gp">$</span> pr -w <span class="m">70</span> -l <span class="m">15</span> -m -4 formated0 formated1 formated2
<span class="go">pr: cannot specify number of columns when printing in parallel</span>
<span class="gp">$</span> <span class="c1"># ...pareil pour le format alternatif (Z au lieu de W)...</span>
<span class="gp">$</span> pr -w <span class="m">70</span> -l <span class="m">15</span> -m -a formated0 formated1 formated2
<span class="go">pr: cannot specify printing accross and printing in parallel</span>
<span class="gp">$</span> <span class="c1"># ...mais le changement de séparateur fonctionne</span>
<span class="gp">$</span> pr -w <span class="m">70</span> -l <span class="m">15</span> -m -s<span class="se">\|</span> formated? <span class="p">|</span> head
<span class="go"> 1</span>
<span class="go"> 2</span>
<span class="go"> 3 2017-10-30 13:56 Page 1</span>
<span class="go"> 4</span>
<span class="go"> 5</span>
<span class="go"> 6 The _fold_ utility is |Fournitures Quantité P |The _fold_ utility is</span>
<span class="go"> 7 filter that shall fold|Crayons 12 |shall fold lines from</span>
<span class="go"> 8 lines from its input f|Feuilles A4 10000 |but breaking the lines</span>
<span class="go"> 9 but breaking the lines|Correcteurs 10 |maximum of _width_ col</span>
<span class="go"> 10 have a maximum of _wid| |bytes, if the *-b* opt</span></code></pre>
<p>C'est une variante intéressante de "<a href="https://pubs.opengroup.org/onlinepubs/9699919799/utilities/diff.html"><code>diff -y</code></a>"…<br><br>
Noter qu'aucun nom de fichier n'est privilégié et qu'il n'y a pas de « mix » particulier. Mais on peut utiliser "<code>-h</code>" pour ajouter son propre titre.</p>
<p>L'implémentation GNU propose aussi une option "<code>-J</code>" qui avec annule la troncature des lignes qui dépassent la largeur spécifiée par "<code>-w</code>".</p>
<h2 id="toc-chasse-fixe">chasse fixe</h2>
<p>L'utilitaire "<code>pr</code>" permet diverses mises en pages plus ou moins avancées pour une <a href="https://advancedweb.fr/impression-brute-directement-sur-une-imprimante-usb-sans-passer-par-le-spouleur-windows/">impression brute/directe</a> (i.e. sans passer par un pilote, l'imprimante pouvant gérer du pur texte et étant dans le mode qui va bien, on y reviendra.) Elle a pléthore d'options pour satisfaire la plupart des caprices. Elles n'ont pas toutes été évoquées ici, et j'invite à parcourir le « <em>man page</em> » associé dans la distribution qu'on utilise.</p>
<table>
<thead>
<tr>
<th>
<a href="https://man.openbsd.org/pr.1">OpenBSD</a>/<a href="https://www.freebsd.org/cgi/man.cgi?query=pr&sektion=1">FreeBSD</a>
</th>
<th><a href="https://linux.die.net/man/1/pr">GNU</a></th>
<th><a href="https://www.ibm.com/support/knowledgecenter/en/ssw_aix_71/com.ibm.aix.cmds4/pr.htm">AIX</a></th>
<th><a href="http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pr.html">POSIX</a></th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td><code>+Ⅰ</code></td>
<td><code>+Ⅰ</code></td>
<td><code>+Ⅰ</code></td>
<td><code>+Ⅰ</code></td>
<td>begin output at page number <code>Ⅰ</code>
</td>
</tr>
<tr>
<td></td>
<td><code>+Ⅰ:Ⅼ</code></td>
<td></td>
<td></td>
<td>output pages from number <code>Ⅰ</code> to <code>Ⅼ</code>
</td>
</tr>
<tr>
<td><code>-Ⅰ</code></td>
<td><code>-Ⅰ</code></td>
<td><code>-Ⅰ</code></td>
<td><code>-Ⅰ</code></td>
<td>produce <code>Ⅰ</code> columns wide</td>
</tr>
<tr>
<td><code>-a</code></td>
<td><code>-a</code></td>
<td><code>-a</code></td>
<td><code>-a</code></td>
<td>fill columns Across the page in a round robin order</td>
</tr>
<tr>
<td></td>
<td><code>-c</code></td>
<td></td>
<td></td>
<td>show Control chars</td>
</tr>
<tr>
<td><code>-d</code></td>
<td><code>-d</code></td>
<td><code>-d</code></td>
<td><code>-d</code></td>
<td>produce Double spaced output</td>
</tr>
<tr>
<td></td>
<td><code>-D Ⅹ</code></td>
<td></td>
<td></td>
<td>use <code>Ⅹ</code> as header Date format</td>
</tr>
<tr>
<td><code>-eⅭⅠ</code></td>
<td><code>-eⅭⅠ</code></td>
<td><code>-eⅭⅠ</code></td>
<td><code>-eⅭⅠ</code></td>
<td>Expand each input <code>Ⅽ</code> (default tab) to <code>n×Ⅰ+1</code> (default 8)</td>
</tr>
<tr>
<td><code>-F</code></td>
<td><code>-F</code></td>
<td><code>-F</code></td>
<td><code>-F</code></td>
<td>use Form feed char. for new pages, not multiple newline</td>
</tr>
<tr>
<td><code>-f</code></td>
<td><code>-f</code></td>
<td><code>-f</code></td>
<td><code>-f</code></td>
<td>same as -F plus pause on stdout</td>
</tr>
<tr>
<td><code>-h _</code></td>
<td><code>-h Ⅹ</code></td>
<td><code>-h Ⅹ</code></td>
<td><code>-h Ⅹ</code></td>
<td>use <code>Ⅹ</code> instead of filename as centered Header</td>
</tr>
<tr>
<td><code>-iⅭⅠ</code></td>
<td><code>-iⅭⅠ</code></td>
<td><code>-iⅭⅠ</code></td>
<td><code>-iⅭⅠ</code></td>
<td>replace multiple blanks by <code>Ⅽ</code> char. (default tab) at <code>n×Ⅰ+1</code> (default 8) in output</td>
</tr>
<tr>
<td></td>
<td><code>-J</code></td>
<td></td>
<td></td>
<td>Join lines, i.e. merge full lines and turn off <code>-W</code> truncation</td>
</tr>
<tr>
<td><code>-l Ⅰ</code></td>
<td><code>-l Ⅰ</code></td>
<td><code>-l Ⅰ</code></td>
<td><code>-l Ⅰ</code></td>
<td>set page Length to <code>Ⅰ</code> lines</td>
</tr>
<tr>
<td><code>-m</code></td>
<td><code>-m</code></td>
<td><code>-m</code></td>
<td><code>-m</code></td>
<td>Merge contents of multiple files (lines side by side)</td>
</tr>
<tr>
<td><code>-nⅭⅠ</code></td>
<td><code>-nⅭⅠ</code></td>
<td><code>-nⅭⅠ</code></td>
<td><code>-nⅭⅠ</code></td>
<td>print line Number separated by <code>Ⅽ</code> char. (default tab) using <code>Ⅰ</code> width column (default 5)</td>
</tr>
<tr>
<td></td>
<td><code>-N Ⅰ</code></td>
<td></td>
<td></td>
<td>first line Number printed with <code>+Ⅰ</code>
</td>
</tr>
<tr>
<td><code>-o Ⅰ</code></td>
<td><code>-o Ⅰ</code></td>
<td><code>-o Ⅰ</code></td>
<td><code>-o Ⅰ</code></td>
<td>precede each line of output with <code>Ⅰ</code> space as Offset</td>
</tr>
<tr>
<td></td>
<td></td>
<td><code>-p</code></td>
<td><code>-p</code></td>
<td>Pause before each page on TTY</td>
</tr>
<tr>
<td><code>-r</code></td>
<td><code>-r</code></td>
<td><code>-r</code></td>
<td><code>-r</code></td>
<td>no diagnostic Reports on file open failure</td>
</tr>
<tr>
<td><code>-sⅭ</code></td>
<td><code>-sⅭ</code></td>
<td><code>-sⅭ</code></td>
<td><code>-sⅭ</code></td>
<td>Separate text columns with <code>Ⅽ</code> char. (default tab) instead of spaces, turn off truncation when no <code>-s</code>
</td>
</tr>
<tr>
<td></td>
<td><code>-SⅭ</code></td>
<td></td>
<td></td>
<td>Separate text columns with <code>Ⅽ</code> char, (default space with <code>-J</code> or tab), but no effect on columns</td>
</tr>
<tr>
<td><code>-t</code></td>
<td><code>-t</code></td>
<td><code>-t</code></td>
<td><code>-t</code></td>
<td>omit five+five lines of header+Trailers on each page</td>
</tr>
<tr>
<td></td>
<td><code>-T</code></td>
<td></td>
<td></td>
<td>omit headers+Trailers and pagination by form feed in input</td>
</tr>
<tr>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td><code>-w Ⅰ</code></td>
<td>set the Width of the line to <code>Ⅰ</code> instead of 72 (when not <code>-s</code>) or 512 (when <code>-s</code>)</td>
</tr>
<tr>
<td></td>
<td><code>-W Ⅰ</code></td>
<td></td>
<td></td>
<td>set page Width to <code>Ⅰ</code> instead of 72, truncate except <code>-J</code> but no interference with <code>-s</code> or <code>-S</code>
</td>
</tr>
</tbody>
</table>
<p>Avant de finir, revenons sur les largeurs par défaut :</p>
<ul>
<li>80 fold</li>
<li>75 fmt</li>
<li>72 par</li>
<li>72 pr</li>
</ul>
<p>Cela va faire bizarre aujourd'hui à ceux qui n'ont pas connu les « polices à <a href="https://fr.wikipedia.org/wiki/Chasse_%28typographie%29">chasse</a> fixe » —<a href="https://en.wikipedia.org/wiki/List_of_monospaced_typefaces">comme Consolas, Courier New, DejaVu Sans Mono, Droid Sans Mono, Inconsolata, Menlo, Lucida Console, Monaco, Terminal, etc.</a>— et les <a href="https://coreight.com/content/guide-polices-typographie">fontes</a> qui caractérisent les <a href="https://web.archive.org/web/20160915231846/https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/3/html/Introduction_to_System_Administration/s1-printers-types-impact.html">imprimantes à impacts</a> :</p>
<ul>
<li>les imprimantes dérivées des téléscripteurs (en fait toute machine à écrire électrique pilotable par ordinateur), initialement, comme les <a href="https://en.wikipedia.org/wiki/Friden_Flexowriter">Friden Flexowriter</a> et les <a href="https://fr.wikipedia.org/wiki/Technique_IBM_%C3%A0_boule">IBM Selectric</a>
</li>
<li>les <a href="http://www.dicofr.com/cgi-bin/n.pl/dicofr/definition/20011012123643">imprimantes à marguerites</a> (similaires à des machines à écrire) ou <a href="https://fr.wikipedia.org/wiki/Imprimante_%C3%A0_marguerite">à tulipe</a> (qui permet d'avoir deux ou trois fontes au lieu d'une seule),</li>
<li>les <a href="https://en.wikipedia.org/wiki/Line_printer">imprimantes à marteau ou à chaîne</a> qu'on trouvait souvent couplés aux <a href="https://fr.wikipedia.org/wiki/Ordinateur_central">mainframes</a>,</li>
<li>les <a href="http://imprimantesthermique.free.fr/les-imprimantes-matricielles.htm">imprimantes matricielles</a> maintenant (et qui ont <a href="http://www.ordinateur.cc/Mat%C3%A9riel/Imprimantes/26180.html">toujours la côte</a> malgré leurs <a href="http://www.ocominc.com/fr/news/Advantages-and-disadvantages-of-dot-matrix-printer.html">défauts</a>, un marché où <a href="https://www.epson.fr/products/printers/dot-matrix-printers">Epson</a> s'en est bien tiré avec son modèle MX-80 —j'en ai eu un) ainsi que Star avec son LC-10,</li>
<li>les <a href="https://en.wikipedia.org/wiki/Line_matrix_printer">imprimantes à peigne, ou ligne matricielle</a> qui sont à mi-chemin entre les imprimantes à ligne et les imprimantes matricielles, comme les Printronix P7000.</li>
<li>les <a href="https://fr.wikipedia.org/wiki/Traceur_%28informatique%29">tables traçantes</a> (qui sont <a href="https://www.azero.fr/comment-choisir-son-traceur/">encore d'usage</a> malgré les technologies d'impression récentes),</li>
</ul>
<p>Les limites (entre 70 et 80 caractères) sont historiques, adaptées aux consoles (plus exactement les moniteurs) standards comme le <a href="https://en.wikipedia.org/wiki/IBM_3270#Models"><em>IBM 3270</em> et ses variantes et compatibles</a> (80 caractères) ainsi que les <a href="https://en.wikipedia.org/wiki/Teleprinter">téléscripteurs</a> (72 caractères) même s'il y a eu rapidement <a href="https://en.wikipedia.org/wiki/Line_printer">des équipements pouvant atteindre 132 caractères</a>… Il se trouve, que pour pour une petite fonte lisible (soit une taille de caractère standard de 10 <a href="https://en.wikipedia.org/wiki/Pitch_%28typewriter%29">pitch</a> ou ~20 CPI —environ ⅙ᵉ pouce ou un <a href="https://en.wikipedia.org/wiki/Pica_%28typography%29">pica</a>—) on a bien 72 <a href="https://en.wikipedia.org/wiki/Characters_per_line#History">CPL</a> …qui correspond au <a href="http://www.papersizes.org/us-paper-sizes.htm">format standard de papier américain</a> « <a href="https://en.wikipedia.org/wiki/Letter_%28paper_size%29"><em>letter</em> de 8.5×11 pouces</a> ».<br>
Cependant, <a href="https://baymard.com/blog/line-length-readability">certains suggèrent de faire moins (entre 50 et 70 CPL)</a>, ce qu'on obtient avec une plus grande fonte (soit une taille de caractère standard de 12 <a href="https://en.wikipedia.org/wiki/Pitch_%28typewriter%29">pitch</a> ou ~17 CPI —alias un elite pour les <a href="https://en.wikipedia.org/wiki/IBM_Selectric_typewriter">IBM Selectric</a>—).<br>
<img src="//img.linuxfr.org/img/68747470733a2f2f656e2e77696b6970656469612e6f72672f77696b692f46696c653a53656c6563747269632d6969692d62616c6c732e6a7067/File:Selectric-iii-balls.jpg" alt="Selectric iii balls" title="Source : https://en.wikipedia.org/wiki/File:Selectric-iii-balls.jpg"><br>
Les journaux ne s'y sont pas trompé en privilégiant le multi colonage (avec un <a href="http://mikeyanderson.com/optimal_characters_per_line">optimum entre 40 et 50 par colonne</a>…) !</p>
<p>Alors, à l'heure des polices proportionnelles (qui posent <a href="https://web.archive.org/web/20180102085458/http://coin.des.experts.pagesperso-orange.fr/reponses/faq9_33.html">des soucis très différents</a> et où il faut raisonner en « pixels » et non plus en caractères), est-ce que tout ceci est dépassé ? Pas vraiment. D'une part la chasses fixe peut s'utiliser avec le matériel récent réglé comme il se doit, d'autre part il y a encore pas mal de machines pro qui sont matricielles dont beaucoup <a href="https://www.retif.eu/encaissement-et-securite/encaissement/caisses-enregistreuses-magasin.html">utilisent de très petites largeurs de papier</a>…<br>
<img src="//img.linuxfr.org/img/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f7468756d622f352f35342f547769747465725f726563656970745f7072696e7465722e6a70672f34343070782d547769747465725f726563656970745f7072696e7465722e6a7067/440px-Twitter_receipt_printer.jpg" alt="Twitter receipt printer" title="Source : https://upload.wikimedia.org/wikipedia/commons/thumb/5/54/Twitter_receipt_printer.jpg/440px-Twitter_receipt_printer.jpg"><br>
(Parmi les principaux fabricants, on trouve <a href="https://sharp.com.sg/web/products/ProdList.asp?Catid=39">Sharp</a>, <a href="http://casio-caisses-enregistreuses.fr/casio-gamme-standard/">Casio</a>, et bien <a href="https://www.bureau-vallee.fr/informatique/materiel-bureautique/calculatrices/calculatrices-imprimante-et-caisse.html">d'autres</a>. Ceci dit, comme toujours, il n'est pas obligatoire <a href="https://www.cdiscount.com/arts-loisirs/r-imprimante+ticket+de+caisse.html#_his_">que l'imprimante et le clavier et le logiciel ne fassent qu'un</a> —les uns et les autres aiment vendre <a href="http://www.ultratactile.fr/10-imprimantes-pour-caisse-enregistreuse">des solutions tout-en-un</a> mais dont on se retrouve prisonnier…) Ces dernières sont souvent des imprimantes thermiques (nombreux <a href="http://www.clemsys.com/40-imprimante-de-caisse-imprimante-etiquette-code-barre">direct</a> ou à <a href="https://www.timcod.fr/produits/imprimantes/bureautiques-thermiques/">transfert</a> et quelques uns <a href="https://imprimante.ooreka.fr/comprendre/thermique">à sublimation</a>) ou <a href="https://fr.wikipedia.org/wiki/Imprimante_LED">à diodes</a>, connectable par USB ou sans fil, fonctionnant sur secteur, etc.</p>
<p>J'ai eu pendant quelques temps la <a href="https://commerce.hpcalc.org/82240b.php"><em>HP 82240B</em></a> qui est une <a href="https://www.cnet.com/products/hp-infrared-printer/specs/">imprimante de poche connectée par IR</a> que je n'ai pu utiliser (en dehors de ma calculatrice) qu'avec <em>Linux</em> ! Comme le rappelle <a href="http://www.hpmuseum.org/forum/archive/index.php?thread-6275.html">Sylvain cote sur HPMuseum</a>, elle a 2 jeux de caractères et 3 fontes (6 et 7 points de haut ainsi qu'une moins connue de 5 points) permettant d'avoir <a href="https://www.calculatorsource.com/m-mcp8850b.html">24 et 32 CPL ainsi que 48</a> !</p>
<p>Mis à part le packaging vraiment bien fichu et l'électronique très bien maîtrisé par l'équipe de <a href="https://fr.wikipedia.org/wiki/Corvallis_%28Oregon%29">Corvallis</a>, on peut faire la même chose avec d'autres composants ou en faire d'autres usages (<a href="https://hackaday.io/project/25616-hp-82240b-ir-receiver-and-printer-interface">suffit d'avoir un adaptateur IR</a>…)</p>
<p><img src="//img.linuxfr.org/img/687474703a2f2f636f6d6d657263652e687063616c632e6f72672f696d616765732f3832323430622d616e676c652d6d656469756d2e6a7067/82240b-angle-medium.jpg" alt="hp-82240b" title="Source : http://commerce.hpcalc.org/images/82240b-angle-medium.jpg"><br>
Sur cette note de nostalgie, j'arrête ce qui n'est plus loin de devenir un roman. À bientôt peut-être pour la suite de cette exploration, et si des points t'ont interpelé ou paru peu clair, n'hésite pas : ça se passe en commentaires.</p>
<div><a href="https://linuxfr.org/users/gilcot/journaux/retrospective-sur-la-mise-en-page-en-console.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126813/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/gilcot/journaux/retrospective-sur-la-mise-en-page-en-console#comments">ouvrir dans le navigateur</a>
</p>
Gil Cot ✔https://linuxfr.org/nodes/126813/comments.atomtag:linuxfr.org,2005:Diary/400982022-01-19T22:28:34+01:002022-01-19T22:28:34+01:00Redécouverte : RoffLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li><a href="#toc-quest-ce-que-roff">Qu'est-ce que roff ?</a></li>
<li><a href="#toc-mod%C3%A8le-comment%C3%A9">Modèle commenté</a></li>
<li>
<a href="#toc-la-voie-dunix">La voie d'UNIX</a><ul>
<li><a href="#toc-ligne-par-ligne">Ligne par ligne</a></li>
<li><a href="#toc-une-t%C3%A2che-un-outil">Une tâche, un outil</a></li>
<li><a href="#toc-un-outil-une-langue">Un outil, une langue</a></li>
<li><a href="#toc-modularit%C3%A9">Modularité</a></li>
<li><a href="#toc-simplicit%C3%A9">Simplicité</a></li>
<li><a href="#toc-s%C3%A9mantique">Sémantique</a></li>
</ul>
</li>
<li><a href="#toc-faire-ses-propres-outils">Faire ses propres outils</a></li>
<li><a href="#toc-un-logiciel-qui-a-50-ans">Un logiciel qui a 50 ans</a></li>
<li><a href="#toc-limitations">Limitations</a></li>
<li>
<a href="#toc-pourquoi-je-my-suis-int%C3%A9ress%C3%A9-optionnel-je-raconte-ma-vie">Pourquoi je m'y suis intéressé (optionnel, je raconte ma vie)</a><ul>
<li><a href="#toc-mes-d%C3%A9buts-avec-la-typographie">Mes débuts avec la typographie</a></li>
<li><a href="#toc-lire-et-retenir">Lire et retenir</a></li>
<li><a href="#toc-documenter-mais-quel-format">Documenter, mais quel format ?</a></li>
<li><a href="#toc-documenter-mais-quel-outil">Documenter, mais quel outil ?</a></li>
<li><a href="#toc-mes-d%C3%A9buts-avec-roff-bonus">Mes débuts avec roff (bonus !)</a></li>
</ul>
</li>
<li><a href="#toc-conclusion">Conclusion</a></li>
</ul>
<p>Bonjour tout le monde !</p>
<p>Je me suis récemment intéressé à comment produire des documents PDF avec roff et ses différents outils (groff, pic, eqn, tbl, refer…). J'apprécie l'outil et le résultat, donc je voulais partager ça avec vous.<br>
(Il y a même du bonus à la fin.)</p>
<p>Comme <a href="//linuxfr.org/news/a-la-recherche-des-sources-de-troff#toc_17">la dépêche la plus complète sur Roff</a> a été postée il y a quasiment dix ans, je suppose que de nombreux utilisateurs actuels du site ne connaissent pas cet outil, ou très peu. Je vais donc en toucher quelques mots, sans entrer dans les détails.</p>
<p>Avant de commencer : je suis plutôt <strong>novice</strong>, et au-delà de quelques démonstrations, ce texte est le reflet de mon parcours avec l'outil.</p>
<h2 id="toc-quest-ce-que-roff">Qu'est-ce que roff ?</h2>
<p>Roff est à la fois un langage et des « compilateurs » de ce langage. Des ensembles de macros existent pour rendre l'écriture plus agréable (et ajouter de la sémantique). Certaines macros sont spécialisées pour produire de la documentation de commandes et de code, d'autres pour écrire des romans, d'autres des documentations techniques, une thèse, <a href="https://bob.diertens.org/corner/useful/gpresent/">des présentations</a>, etc.</p>
<p>Bien que sa conception remonte au début des années 70, Roff est <strong>toujours d'actualité</strong>. Différentes implémentations sont disponibles, comme <a href="https://savannah.gnu.org/git/?group=groff"><code>groff</code></a>, ou des implémentations spécialisées, comme <a href="https://mandoc.bsd.lv/"><code>mandoc</code></a> pour la création de pages de manuel. Il est également utilisé pour la création de RFC !</p>
<p>Divers formats sont possibles, les plus courants sont les formats pdf et tty (pour des pages de manuel en ligne de commande), mais le html est aussi possible, ou encore le simple texte.</p>
<p>NB : dans la suite je parle indistinctement de <code>roff</code> et <code>troff</code> pour désigner le langage. En ligne, vous trouverez les deux appellations.</p>
<h2 id="toc-modèle-commenté">Modèle commenté</h2>
<p>Se mettre à roff n'est pas trivial. La documentation pour un débutant est pas terrible, ce qui est quand même super dommage (et un peu ironique). L'outil mériterait pourtant d'être plus connu ! Donc rien de mieux qu'un modèle, fortement commenté, pour montrer l'exemple :</p>
<ul>
<li><a href="https://git.baguette.netlib.re/karchnu/groff-template">Dépôt de code avec un modèle</a></li>
<li>
<a href="https://t.karchnu.fr/doc/grofftut.pdf">Le modèle généré</a> (attention, <strong>à voir HORS du navigateur</strong> pour un bon rendu)</li>
</ul>
<p>Ce modèle a pour objectif de présenter les différents outils disponibles avec roff; le modèle est une démonstration de ce qu'on est <strong>facilement</strong> en mesure d'obtenir. J'ai fait ce document parce que c'est ce que j'aurais aimé avoir à mes débuts.</p>
<p>Autre exemple (complet) de document :</p>
<pre><code class="groff">.<span class="k">TL</span> <span class="c">\" titre du document</span>
Exemple de document
.<span class="k">AU</span> <span class="c">\" auteur</span>
Karchnu
.<span class="k">AB</span> <span class="c">\" début de l'abstract</span>
Ceci est un exemple de document écrit avec roff.
.<span class="k">AE</span> <span class="c">\" fin de l'abstract</span>
.<span class="k">NH</span> <span class="c">\" titre de section</span>
Titre
.<span class="k">PP</span> <span class="c">\" paragraphe indenté</span>
Paragraphe.
.<span class="k">PS</span> <span class="c">\" début de dessin avec "pic"</span>
box
line
circle
.<span class="k">PE</span> <span class="c">\" fin de dessin avec "pic"</span></code></pre>
<p>Le résultat ressemble à ceci : <img src="//img.linuxfr.org/img/68747470733a2f2f742e6b617263686e752e66722f7075622f726f66662f6578656d706c652d646f63756d656e742d726f66662e706e67/exemple-document-roff.png" alt="Exemple de document roff avec macros ms" title="Source : https://t.karchnu.fr/pub/roff/exemple-document-roff.png"><br>
Comme on peut voir, il n'y a que peu de code. Roff est un format pensé pour être écrit par des humains, il n'y a donc que très peu de superflu.</p>
<h2 id="toc-la-voie-dunix">La voie d'UNIX</h2>
<p>Les outils autour de roff (groff, tbl, eqn, pic, grap, etc.) ont plein de qualités.</p>
<h3 id="toc-ligne-par-ligne">Ligne par ligne</h3>
<p>La conception des outils est simple : tout repose sur la lecture ligne par ligne des sources.<br>
De fait, les outils sont simples à comprendre et à étendre.</p>
<h3 id="toc-une-tâche-un-outil">Une tâche, un outil</h3>
<p>Voici un exemple de compilation d'un document roff :</p>
<pre><code class="sh">soelim < sources.roff <span class="p">|</span> eqn <span class="p">|</span> tbl <span class="p">|</span> pic <span class="p">|</span> grap <span class="p">|</span> refer <span class="p">|</span> groff -Tpdf > document.pdf</code></pre>
<p>Chaque outil gère un aspect du document :</p>
<ul>
<li>soelim = interprète les requêtes ".so" (toutes les sources en un seul flux, un « include » si vous préférez)</li>
<li>eqn = équations</li>
<li>tbl = tableaux</li>
<li>pic = schémas</li>
<li>grap = graphes</li>
<li>refer = références bibliographiques</li>
<li>groff = compilateur de roff</li>
</ul>
<p>Chacun de ces outils prend en entrée le texte source de tout le document et produit du roff.</p>
<h3 id="toc-un-outil-une-langue">Un outil, une langue</h3>
<p>Un document roff n'est pas écrit qu'en roff. Presque chaque outil a sa propre langue, permettant de décrire précisément <strong>l'intention de l'auteur</strong>.</p>
<p>Le meilleur exemple de ça est pour moi <strong>pic</strong>. Voici l'exemple donné précédemment :</p>
<pre><code class="groff">box
line
circle</code></pre>
<p>Ici il n'est plus question d'écrire du roff à la main, mais d'avoir un langage dédié à l'élaboration de schémas. Cela permet de décrire le rendu souhaité, sans distraction.</p>
<p>Il est également possible de créer des fonctions pour factoriser au mieux le code. Du <code>roff</code> peut être inclus pour éviter de réécrire des fonctionnalités qui existent déjà (comme la gestion des polices par exemple). L'ensemble forme un tout cohérent.</p>
<p>Faire des schémas comme ceux-ci est simple :<br>
<img src="//img.linuxfr.org/img/68747470733a2f2f742e6b617263686e752e66722f7075622f726f66662f677261766974616c2d6c656e73696e675f7069632d6578616d706c652e706e67/gravital-lensing_pic-example.png" alt="Exemple de schéma avec pic : lentille gravitationnelle" title="Source : https://t.karchnu.fr/pub/roff/gravital-lensing_pic-example.png"><br>
<img src="//img.linuxfr.org/img/68747470733a2f2f742e6b617263686e752e66722f7075622f726f66662f63697263756c61722d6469666672616374696f6e5f7069632d6578616d706c652e706e67/circular-diffraction_pic-example.png" alt="Exemple de schéma avec pic : diffraction circulaire" title="Source : https://t.karchnu.fr/pub/roff/circular-diffraction_pic-example.png"><br>
De plus, la description de ces schémas se rapproche de la programmation, et tout peut être paramétré. Il serait donc possible de modifier les tailles des différents composants de ces images de manière dynamique, via de simples variables.</p>
<h3 id="toc-modularité">Modularité</h3>
<p>Les outils sont indépendants les uns des autres et peuvent être remplacés à tout moment. Si on a une nouvelle implémentation trop géniale de <code>tbl</code>, son remplacement dans la chaîne de compilation est trivial.</p>
<h3 id="toc-simplicité">Simplicité</h3>
<p><code>roff</code> est largement moins complexe que LaTeX. Pas besoin de plusieurs giga d'espace disque pour générer un PDF avec deux paragraphes; seuls quelques binaires minuscules sont nécessaires.</p>
<p>Autre métrique pour juger de la complexité de l'application : le temps de compilation est instantané, y compris sur de très vieilles machines et de gros documents.</p>
<p>Cette rapidité a un effet de bord plutôt appréciable; il est possible d'avoir un rendu généré à chaque modification des fichiers. C'est ce que j'utilise pour avoir un retour immédiat de ce que j'écris grâce à <a href="https://github.com/clibs/entr"><code>entr</code></a>. D'ailleurs, si vous utilisez le makefile de mon dépôt, vous pouvez juste taper <code>make serve</code> et vous aurez par défaut votre document généré dans <code>/tmp</code>, et regénéré à chaque modification.</p>
<h3 id="toc-sémantique">Sémantique</h3>
<p>Roff permet d'étendre le langage en créant des macros. Par exemple, je me suis fait une macro "SECTION" pour ajouter de nouveaux titres numérotés :</p>
<pre><code class="groff"> .SECTION Nouveau chapitre
Coucou ceci est le début du chapitre.</code></pre>
<p>Les macros permettent de changer facilement le style du document, tout en ajoutant de la sémantique.</p>
<p>Les différentes commandes (pic, grap, etc.) possèdent également des macros (ou fonctions). Cela permet de faire du code réutilisable et configurable.</p>
<h2 id="toc-faire-ses-propres-outils">Faire ses propres outils</h2>
<p>Créer de nouveaux outils pour roff est assez simple, il faut juste faire un programme qui prend en entrée les sources du document et renvoie des commandes roff.</p>
<p>Compilation d'un document avec un nouvel outil révolutionnaire :</p>
<pre><code class="sh"> eqn < source.roff <span class="p">|</span> nouvel-outil <span class="p">|</span> groff -Tpdf > document.pdf</code></pre>
<p>Par exemple, j'ai ajouté de la coloration syntaxique avec <a href="https://github.com/Gavinok/ghighlight"><code>ghighlight</code></a> (préprocesseur roff, qui fait appel à <a href="https://www.gnu.org/software/src-highlite/"><code>source-highlight</code></a>). Dans les sources de mes documents, ça donne :</p>
<pre><code class="C"> <span class="p">.</span><span class="n">SOURCE</span> <span class="n">C</span>
<span class="kt">int</span> <span class="n">main</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">.</span><span class="n">SOURCE</span></code></pre>
<p>Et voilà, on a du C coloré dans le document final.</p>
<p>NB : j'ai également vu dans un ancien article linuxfr qu'il existait d'autres outils pour mettre de la coloration syntaxique dans troff. Notamment, <a href="https://www.computerhope.com/unix/uvgrind.htm"><code>vgrind</code></a> qui servait autrefois à ajouter de la couleur à du code dans le terminal, et qui peut se coupler avec <a href="https://github.com/pjfichet/ugrind"><code>ugrind</code></a> pour en faire un préprocesseur Roff. Je verrai plus tard si <code>vgrind</code> pourrait remplacer avantageusement ma solution, il semble couvrir moins de langages et ma solution fonctionne, donc bidouiller vgrind n'est pas dans mes priorités là tout de suite.</p>
<h2 id="toc-un-logiciel-qui-a-50-ans">Un logiciel qui a 50 ans</h2>
<p>Je ne vais pas revenir sur toute l'histoire derrière Troff. D'<a href="//linuxfr.org/news/a-la-recherche-des-sources-de-troff">autres l'ont fait avant moi</a> et mieux que je ne saurais le faire. En revanche, le fait que ce langage soit si vieux est important à mentionner, à plusieurs égards.</p>
<ol>
<li>Le langage est robuste dans le temps; il ne semble pas avoir beaucoup changé au fil des décennies.</li>
<li>La compilation d'un document roff est quasi instantanée, la complexité du langage étant adaptée aux machines des années 70.</li>
<li>Il existe plusieurs implémentations des mêmes outils, souvent faites à différentes époques. Cela peut engendrer des confusions.</li>
<li>La documentation autour du langage et de ses outils est inégale.
<ul>
<li>Certains outils ont une documentation exceptionnellement bonne, à l'instar de <a href="http://doc.cat-v.org/unix/v8/picmemo.pdf">pic</a>, ou de Roff lui-même qui a <a href="http://www.kohala.com/start/troff/v7man/trofftut/trofftut.ps">une documentation toujours valide</a> (et excellente) depuis 1978. Le site <a href="https://troff.org/">troff.org</a> aide beaucoup à se documenter.</li>
<li>En revanche, tout n'est pas simple, et la documentation des <em>requêtes</em> (commandes Roff) peut laisser à désirer. Notamment dans la documentation de <a href="https://www.gnu.org/software/groff/">Groff</a>, la seule implémentation que j'ai utilisée jusque-là.</li>
<li>Les pages de manuel sont souvent incomplètes ou pas à jour, mais ça s'améliore.</li>
</ul>
</li>
<li>Malgré son âge et les nombreuses implémentations abandonnées, certaines implémentations sont toujours bien actives. Par exemple, Groff reçoit encore régulièrement de nombreux commits, et <a href="https://mandoc.bsd.lv/"><code>mandoc</code></a> a été présenté <a href="https://www.openbsd.org/papers/eurobsdcon2015-mandoc.pdf">en 2015</a> puis <a href="https://www.bsdcan.org/2018/schedule/events/958.en.html">en 2018</a> comme étant une implémentation dédiée à la création de pages de manuel (spécifiquement pour l'ensemble de macros <strong>mdoc</strong>). OpenBSD a officiellement adopté <strong>mandoc</strong> pour sa documentation.</li>
</ol>
<p>Roff a 50 ans, et a encore de beaux jours devant lui.</p>
<p>Par ailleurs, je conseille la lecture de <a href="http://www.schemamania.org/troff/for-the-love-of-troff.pdf">For the love of troff</a> qui explique pourquoi on ne se débarrassera pas d'un outil comme <code>troff</code> facilement.</p>
<p>NB : <em>de ce que j'ai compris</em>, un jour <code>groff</code> a été devancé par TeX sur quelques points. Par exemple la gestion de l'alignement du texte sur les lignes, qui se faisait ligne-par-ligne au lieu de prendre en compte tout le paragraphe. De même, les équations étaient mieux gérées sur LaTeX. Mais le développement se déroulant à bon train, il ne me semble pas que ces critiques soient toujours d'actualité. Si vous en savez plus, n'hésitez pas à vous manifester dans les commentaires !</p>
<h2 id="toc-limitations">Limitations</h2>
<p><strong>Je ne prétends pas être un expert</strong>. Je suis un simple utilisateur qui a fait un petit bout de chemin avec ces outils et <strong>uniquement avec les macros ms</strong>. Parfois, ce chemin s'est transformé en parcours du combattant, voici quelques raisons :</p>
<ol>
<li>
<strong>L'inclusion d'images</strong>. C'est possible et je l'ai fait dans mon modèle présenté plus haut, mais les tailles des images sont mal gérées. J'ai un peu bidouillé pour que ça tombe en marche (2 lignes, rien de bien méchant). Par ailleurs, le format PS ou PDF semble imposé pour les images.</li>
<li>
<strong>Les références intra-document</strong>. Faire référence à une section ou un chapitre par exemple.
<ol>
<li>La bibliographie est correctement gérée avec <code>refer</code>, mais l'outil ne gère pas les références vers des sections d'un document.</li>
<li>Les macros <code>ms</code> ne semblent pas comporter de macros pour gérer automatiquement des références. Il existe une macro pour créer un sommaire, mais c'est à peu près tout.</li>
<li>Il est possible d'écrire explicitement une référence. Le problème est qu'il faut gérer la numérotation des pages dans les références à la main.</li>
<li>Il est possible de faire <a href="https://www.reddit.com/r/groff/comments/mly4cb/an_intermediate_guide_to_groff_my_custom_ms/">soit-même des macros gérant les références intra-document</a>, c'est juste dommage que ce ne soit pas de base, surtout pour les débutants.</li>
<li>J'ai peut-être manqué l'outil qui fait ça et que tout le monde utilise depuis toujours, comme le dernier des boulets. À défaut de trouver une meilleure solution, j'ajouterai des macros pour gérer ça dans mon modèle.</li>
</ol>
</li>
<li>
<strong>L'inclusion de nouvelles polices</strong>. C'est faisable, mais pas simple.
<ol>
<li>C'est <em>simplifié</em> en utilisant le script <a href="https://www.schaffter.ca/mom/bin/install-font.sh"><code>install-fonts.sh</code></a> (<a href="https://tkurtbond.github.io/posts/2021/07/17/groff-and-install-fontsh-and-installing-fonts-for-use-in-groff/">un peu de documentation à ce propos</a>).</li>
<li>Pas de ligatures avec le script présenté au point précédent. J'ai ajouté la police <a href="https://github.com/tonsky/FiraCode">FiraCode</a> et les ligatures ne sont pas présentes. Je n'ai pas suffisamment de connaissances à ce sujet pour savoir ce qui ne va pas.</li>
<li>Le format accepté des fichiers de polices est le TrueType Font (du moins, c'est le format qui peut être facilement converti dans le format accepté par <code>groff</code>), et je ne crois pas qu'il y ait beaucoup d'autres formats disponibles.</li>
<li>
<code>neatroff</code> rend facile l'ajout de polices, mais je n'ai pas encore joué avec cette implémentation.</li>
</ol>
</li>
<li>
<strong>Des notions contre-intuitives</strong>. La gestion des environnements, par exemple, réserve quelques surprises.</li>
<li>
<strong>L'intégration de liens PDF</strong>.
<ul>
<li>Il faut activer de nouvelles macros (les macros <code>ms</code> n'incluent pas la gestion de liens PDF).</li>
<li>Là encore, c'est géré de base dans <code>neatroff</code>.</li>
</ul>
</li>
<li>
<strong>Rendu navigateur moche</strong>. Je ne sais pas quelle est la cause, mais le texte de base est hideux.</li>
</ol>
<p>En bref, <strong>rien d'insurmontable</strong>.<br>
Ces problèmes peuvent probablement se résoudre en contactant une communauté d'utilisateurs. Je pense également que l'usage des macros <code>ms</code> y est pour quelque-chose, ces macros sont parmi les plus simples mais offrent moins de possibilités.</p>
<p>Dans les problèmes rencontrés <strong>mais réglés</strong> :</p>
<ol>
<li>
<strong>UTF-8</strong>. Il faut appeler <code>preconv</code> dans la chaîne de compilation ou faire appel à <code>groff -k</code>. J'ai eu des problèmes (je ne me souviens plus des détails) qui m'ont mené à implémenter <a href="https://github.com/KaneRoot/grofftut/blob/master/bin/utf8-to-ms.sh">un filtre</a> remplaçant les caractères UTF-8 (principalement des accents) en leurs macros <code>ms</code> respectives. Comme pour <code>preconv</code>, il suffit de mettre mon script dans le pipeline de compilation et l'UTF8 est géré.</li>
<li>La confusion entre les implémentations, les macros et où trouver de la documentation. Les pages de manuel sont parfois incohérentes entre elles, ou incomplètes, voire peu claires. Ça prend un peu de temps pour être à l'aise, et même si je n'ai pas encore appris tous les concepts, ça rentre petit à petit.</li>
<li>Sous OpenBSD, le fichier de configuration <code>troffrc</code> présent par défaut empêche catégoriquement de justifier les paragraphes. C'est pour cela que le dépôt du modèle inclut un <code>troffrc</code> personnalisé. Rien de bien méchant, mais c'était frustrant à mes débuts.</li>
</ol>
<p>En tout cas, avoir un exemple comme le modèle que je vous ai partagé m'aurait grandement aidé.</p>
<h2 id="toc-pourquoi-je-my-suis-intéressé-optionnel-je-raconte-ma-vie">Pourquoi je m'y suis intéressé (optionnel, je raconte ma vie)</h2>
<p>Avant de terminer, un petit mot sur la raison qui m'a poussé à me renseigner sur Roff, <strong>au cas où ça intéresse quelqu'un</strong>.</p>
<h3 id="toc-mes-débuts-avec-la-typographie">Mes débuts avec la typographie</h3>
<p>J'ai passé une thèse en 2019 en informatique. Cette expérience m'a obligé à bouffer de la création de documents à n'en plus finir (ma thèse a été 6 mois de développement, le reste c'est de l'écriture de papiers). J'aimais pas ça, mais petit à petit j'y ai pris goût. Écrire un papier, c'est voir son idée grandir, se développer, se préciser, et obtenir un meilleur rendu (pour satisfaire un journal qui récolte tout le fruit de ton travail sans un merci parce que t'es complètement sa p…).</p>
<p>En tout cas, voir son papier gagner en maturité, voir le rendu s'améliorer sous les <s>ordres</s> conseils de son directeur de thèse, c'était assez plaisant.</p>
<h3 id="toc-lire-et-retenir">Lire et retenir</h3>
<p>Aujourd'hui, comme je n'ai pas eu le temps de le faire pendant mes études, je me documente sur plein de sujets qui m'intéressent. Par exemple, j'ai commencé à regarder des langages de programmation qui ont des paradigmes que je n'ai pas suffisamment explorés. Un peu d'astronomie, de politique aussi.</p>
<p>Plus je bouquine, plus j'ai envie de résumer ce que je lis. <strong>Documenter pour ne pas oublier</strong>. Je ne suis pas un grand lecteur, et relire un livre m'est rébarbatif : je lis pour apprendre, pas pour le plaisir de lire.</p>
<h3 id="toc-documenter-mais-quel-format">Documenter, mais quel format ?</h3>
<p><em>Le format web</em> :<br>
Résumer un livre via un article de blog n'est pas un format qui me convient. Le web est selon moi un foutoir incroyable, le html incluant de force une sémantique (pauvre) et se basant sur des outils trop compliqués. Tout change, tout le temps : les outils, les langages, les sites web. Je ne parle même pas des centaines de technos existantes et bâclées. Un site ça vit, ça meurt. Je veux sortir de cette logique.</p>
<p><em>Le format papier</em> :<br>
Un document PS ou PDF s'approche du format papier, et selon moi les papiers de recherche ont le meilleur format pour résumer et expliquer des concepts. Comme le web, un document papier comporte des titres, tableaux, schémas, couleurs, graphes, équations et un style facilement modifiable. Mais le format papier possède également des notes en bas de page pour ce qui relève du détail anecdotique. C'est un format connu, universel et agréable. Autre avantage : pouvoir collecter ces documents sans l'intermédiaire du web (nos navigateurs sont des monstres), apprécier une lecture hors ligne. Tout ça c'est important <strong>pour moi</strong>.</p>
<h3 id="toc-documenter-mais-quel-outil">Documenter, mais quel outil ?</h3>
<p>Pour ma thèse, j'ai utilisé LaTeX, comme tout le monde. J'aime plutôt bien cet outil, mais je voulais en expérimenter d'autres, plus minimalistes. LaTeX a quelques gros avantages par rapport à sa concurrence (LibreOffice et MS Word), mais il reste plutôt gourmand (taille, durée de compilation) et complexe. Idem pour les outils qui gravitent autour. Au fond, ai-je besoin de quelque-chose d'aussi lourd pour mes documents perso ?</p>
<p>Je veux un format papier et typographier sémantiquement mon document (par exemple, lorsque je cite un module ou une fonction). Au revoir markdown.</p>
<p>Roff a piqué ma curiosité de part son âge et son adoption (plus ou moins) universelle sur les distributions Linux et les BSD. Après tout, pourquoi vouloir installer d'autres outils que ceux qui sont déjà présents, s'ils font le travail ? Puis je suis l'élite de la nation au RSA, j'ai le temps de me documenter sur des langages obscurs.</p>
<h3 id="toc-mes-débuts-avec-roff-bonus">Mes débuts avec roff (bonus !)</h3>
<p>Après avoir dissipé légèrement ma confusion entre tous les outils existants (implémentations, macros, les outils annexes), et surtout après avoir vu <a href="https://troff.org/prog.html">une page montrant des exemples</a> qui m'a bien motivé à pratiquer, j'ai fait quelques tests sur ma machine.</p>
<p>Par la suite j'ai résumé ce que je lisais avec <code>groff</code>. Je n'ai terminé aucun de mes documents pour le moment, j'ai un peu la bougeotte. J'ai quand même bien entamé certains sujets, quelques exemples de résumés :</p>
<ul>
<li>
<a href="https://t.karchnu.fr/doc/haskelltut.pdf">Haskell</a> pour explorer la programmation fonctionnelle. Gros morceau que je tente d'expliquer à ma façon (sans trop de jargon mathématique). J'ai expliqué les bases et j'ajoute des parties de temps en temps. Mon objectif étant de résumer tout ce que j'ai pu lire sur le net à ce sujet; marre de fouiller des centaines de commentaires reddit pour avoir une explication cohérente. Une fois que le document sera suffisamment avancé j'en ferai peut-être une dépêche sur linuxfr (abonne-toi, mets la cloche).</li>
<li>
<a href="https://t.karchnu.fr/doc/universe-from-nothing.pdf">« A Universe From Nothing »</a> de <em>Lawrence Krauss</em>. Je m'intéresse aussi à l'astronomie, et j'ai commencé à résumer le livre. Je suis loin d'avoir fini de résumer (seuls les 2 premiers chapitres sont réellement là), mais ça peut donner une idée d'un rendu.</li>
</ul>
<p>J'ai également quelques notes par ailleurs, pas assez avancées pour être montrées pour le moment. Notamment mon point de vue sur les langages de programmation en général (petite explication du comment et du pourquoi de Haskell, LISP, tcl, Zig, assembleur, m4, dc, awk, etc.).</p>
<p>NB : le style de ces documents n'est pas définitif. Je mets peut-être un peu trop de couleurs et la police pourrait être changée par endroits. Mais cela donne de bons exemples de ce qui est possible avec <code>troff</code>.</p>
<h2 id="toc-conclusion">Conclusion</h2>
<p>Parfois j'ai l'impression que les outils disponibles pour <code>troff</code> sont en avance par rapport aux outils modernes. Par exemple, <code>pic</code> est un outil de programmation pour générer un schéma, avec tout la souplesse que ça apporte. Faire des schémas avec une GUI me semble, dans une certaine mesure, plus contraignant. C'est d'autant plus le cas quand on doit faire plusieurs schémas pour un même document, forcer le même style pour tous les schémas est trivial avec <code>pic</code> (mêmes polices, épaisseur de traits, etc.).</p>
<p>Malgré avoir utilisé LaTeX pendant des années, j'ai davantage lu la documentation de <code>groff</code> et je pense mieux le maîtriser.</p>
<p>Les documents produits sont d'une qualité suffisante à mon goût. Je vois encore des modifications à apporter à mes macros et je continue de jouer avec l'outil, mais j'ai suffisamment de recul pour comprendre que <code>roff</code> me convient.</p>
<p>Bref, j'attends vos retours ou vos questions si vous en avez. Merci de m'avoir lu jusqu'ici !</p>
<p>PS: si vous éprouvez une haine viscérale envers Roff et consorts, passez votre chemin. J'ai aucun problème avec ça, mais ne perdons pas notre temps dans des dialogues de sourds.</p>
<p>PS : si Sygne est toujours parmi nous, je veux bien savoir si son projet <code>utroff</code> est toujours pertinent. Il en avait fait des dépêches il y a maintenant 8 ans, et le site est malheureusement hors ligne maintenant.</p>
<div><a href="https://linuxfr.org/users/karchnu/journaux/redecouverte-roff.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126629/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/karchnu/journaux/redecouverte-roff#comments">ouvrir dans le navigateur</a>
</p>
karchnuhttps://linuxfr.org/nodes/126629/comments.atomtag:linuxfr.org,2005:Diary/398232021-06-26T18:49:30+02:002021-06-26T18:54:52+02:00Police partout, justification où on veutLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Salut les gens, et les autres,</p>
<p>bon, il faut bien le reconnaître ! Je dois avoir la réputation d’être une fille facile, je ne vois que ça comme explication à peu près rationnelle qui expliquerait qu’on me dise « eh, tu ne voudrais écrire un journal ou une dépêche sur ce sujet par hasard ? » Remarquez, ça marche assez bien. La première fois, c’était pour l’hommage à <a href="//linuxfr.org/news/hommage-a-frances-allen">Frances Allen</a>, qui m’a pris quatre jours. Cette fois-ci, il s’agit de polices.</p>
<p>Mais, comme j’ai un <a href="https://dutailly.net/">site</a> à alimenter, que c’est long<sup id="fnref1"><a href="#fn1">1</a></sup> et illustré et que mettre des illustrations sur LinuxFr c’est compliqué, j’en ai fait un <a href="https://dutailly.net/ou-il-est-question-de-police">article</a> (voire un petit traité) qui essaie de faire le tour de la question.</p>
<p>Donc les polices.</p>
<h2 id="toc-comment-on-parle-des-polices">Comment on parle des polices</h2>
<p>Si vous faites une recherche, vous vous rendrez compte que, quand on parle de polices, on parle toujours d’un angle précis : typographie, web ou<sup id="fnref2"><a href="#fn2">2</a></sup> troubles de la vision ou de la lecture, et pas vraiment d’une façon globale, comme si tous ces domaines étanches alors que c’est faux, définitivement faux. Et personne ne parle de l’environnement de bureau. </p>
<p>Pourtant, choisir une police pour son environnement de bureau est crucial pour le confort du travail. Si le vôtre ne vous le permet pas, changez-en.</p>
<p>En outre, notamment pour ce qui n’est pas web, ça reste orienté mac et Windows et ça suggère souvent de garder, pour la bureautique, les mêmes vieilles polices pourries à savoir Arial et Times (par pitié, arrêtez de les utiliser, elles sont moches et pas super lisibles).</p>
<h2 id="toc-de-quoi-ça-parle">De quoi ça parle ?</h2>
<p>L’article <a href="https://dutailly.net/ou-il-est-question-de-police">« Où il est question de police »</a> hein, pas les autres textes que j’ai pu lire pour le rédiger.</p>
<p>Ça pontifie pour commencer en donnant quelques définitions clés, important pour savoir de quoi on parle : police, fonte, graisser, romain. Vous noterez que ces expressions typographiques ont toutes d’autres sens. </p>
<p>Ça expose les cinq grandes catégories de police, sachant qu’il y a bien d’autres classifications. Mais celle-là est la plus simple donc les polices : bâton, avec empattement, scriptes, fantaisie et à chasse fixe. Il y a même une illustration, que je vous mets pour éviter que vous ne bâilliez trop d’ennui<sup id="fnref3"><a href="#fn3">3</a></sup></p>
<p><img src="//img.linuxfr.org/img/68747470733a2f2f64757461696c6c792e6e65742f494d472f706e672f63696e735f74797065735f64655f706f6c6963652e706e67/cins_types_de_police.png" alt="Les grands types de police" title="Source : https://dutailly.net/IMG/png/cins_types_de_police.png"></p>
<p>Ça parle de formats de police et de police graphite (vous saviez-vous qu’on les dit intelligentes ?).</p>
<p>Ça donne des critères de choix : </p>
<ul>
<li>licence, pas détaillées, sinon je ne m’en sortais pas, mais cela fait partie des critères à prendre en compte ;</li>
<li>collection de glyphes, et ça vous explique comment voir ça avec <a href="https://fr.wikipedia.org/wiki/FontForge">FontForge</a> et la <a href="https://wiki.gnome.org/Apps/Gucharmap">table des caractères de GNOME (EN)</a> (en téléchargement dans toutes les bonnes distributions) ;</li>
<li>dessin des lettres, notamment quels caractères regarder pour faire son choix. Re-joli dessin pour que vous voyiez de quoi il s’agit :</li>
</ul>
<p><img src="//img.linuxfr.org/img/68747470733a2f2f64757461696c6c792e6e65742f494d472f706e672f64657373696e5f64655f706f6c696365732e706e67/dessin_de_polices.png" alt="Le dessin des caractères a, o, I, l, 1, O, 0, p et q dans plusieurs polices" title="Source : https://dutailly.net/IMG/png/dessin_de_polices.png"></p>
<p>Ça se demande s’il faut ou pas des polices empattées (ben, c’est pas évident), s’il faut ou pas des polices pour les personnes dyslexiques (ben, c’est pas évident non plus) et si et comment on doit embarquer les polices. Et ça explique tout ça et comment faire pour les embarquer. Et aussi, que faire des dessins au format svg avec du texte.</p>
<p>Et, évidemment (évident, vraiment ?) ça parle de mode. </p>
<h2 id="toc-où-trouver-des-polices">Où trouver des polices ?</h2>
<p>À part dans votre suite bureautique préférée, il faudrait voir si votre distribution préférée en propose d’autres (c’est le cas de Mageia<sup id="fnref4"><a href="#fn4">4</a></sup>, pour les autres, je ne sais pas à vrai dire).</p>
<p>Je vous propose un choix de sites, il y en a plein d’autres :</p>
<ul>
<li>
<a href="https://www.1001freefonts.com/">1001freefonts</a> qui permet facilement de rechercher par licence ;</li>
<li>
<a href="https://www.dafont.com/">Dafont</a>, peut-être le plus connu, on peut chercher par licence, mais ce n’est pas extrêmement évident ;</li>
<li>
<a href="https://fontmeme.com/polices">FontMeme</a>, je crois que c’est celui qui affiche la licence des polices de la façon la plus évidente ;</li>
<li>
<a href="https://www.cufonfonts.com/">Cufon Fonts, en anglais</a> qui propose les mêmes catégories que celles que j’ai définies plus haut, plus des pictos et autres symboles.</li>
</ul>
<h2 id="toc-quest-ce-ça-ne-dit-pas">Qu’est-ce ça ne dit pas ?</h2>
<p>Ça vous aide à choisir une police, ça vous dit ce que j’utilise, ça suggère des polices, notamment <a href="http://www.luciole-vision.com/">Luciole</a>, police élégante et très complète qui a été dessinée en tenant compte des personnes qui ont des troubles de la vision.</p>
<p>Mais ça ne vous dit pas quelle police choisir exactement, parce que tout ça dépend de plusieurs facteurs :</p>
<ul>
<li>à quoi va servir cette police ;</li>
<li>pour quel public ;</li>
<li>que comportera votre texte, des formules de math, du code… ;</li>
<li>et puis aussi, vos goûts qui doivent entrer en ligne de compte.</li>
</ul>
<p>Ça ne parle pas spécifiquement de typographie non plus, parce que, c’est un autre sujet en fait.</p>
<p>Rappel : <a href="https://dutailly.net/ou-il-est-question-de-police">Où il est question de police</a></p>
<p>Bonne lecture.</p>
<p>PS : tout ça repose sur des tas de trucs qui sont référencées dans l’article (et j’ai tout lu).</p>
<div class="footnotes">
<hr>
<ol>
<li id="fn1">
<p>Pour tout dire ça m’a pris autant de temps que la dépêche sur Frances Allen, mais je connaissais déjà le sujet alors que j’ignorais tout de Frances Allen. <a href="#fnref1">↩</a></p>
</li>
<li id="fn2">
<p>Un « ou » définitivement exclusif. <a href="#fnref2">↩</a></p>
</li>
<li id="fn3">
<p>N’empêche c’est un sujet super intéressant. <a href="#fnref3">↩</a></p>
</li>
<li id="fn4">
<p>Vous ne croyiez tout de même pas que j’allais rater une occasion de parler de ma distribution favorite tout de même. <a href="#fnref4">↩</a></p>
</li>
</ol>
</div>
<div><a href="https://linuxfr.org/users/ysabeau/journaux/police-partout-justification-ou-on-veut.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/124712/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/ysabeau/journaux/police-partout-justification-ou-on-veut#comments">ouvrir dans le navigateur</a>
</p>
Ysabeau 🧶 🧦https://linuxfr.org/nodes/124712/comments.atomtag:linuxfr.org,2005:Bookmark/25762021-01-23T16:41:28+01:002021-01-23T16:41:28+01:00Histoire de la famille de polices de caractères Nokia<a href="https://www.linkedin.com/pulse/unsung-heroes-finnish-typeface-design-juho-veps%C3%A4l%C3%A4inen/">https://www.linkedin.com/pulse/unsung-heroes-finnish-typeface-design-juho-veps%C3%A4l%C3%A4inen/</a> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/123061/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/pulkomandy/liens/histoire-de-la-famille-de-polices-de-caracteres-nokia#comments">ouvrir dans le navigateur</a>
</p>
pulkomandyhttps://linuxfr.org/nodes/123061/comments.atomtag:linuxfr.org,2005:Bookmark/25382021-01-16T12:02:16+01:002021-01-16T12:02:16+01:00Conception d'une nouvelle police de caractères musicale libre pour MuseScore<a href="https://www.youtube.com/watch?v=XGo4PJd1lng">https://www.youtube.com/watch?v=XGo4PJd1lng</a> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/122963/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/pulkomandy/liens/conception-d-une-nouvelle-police-de-caracteres-musicale-libre-pour-musescore#comments">ouvrir dans le navigateur</a>
</p>
pulkomandyhttps://linuxfr.org/nodes/122963/comments.atomtag:linuxfr.org,2005:Diary/392802020-08-01T11:52:09+02:002020-08-01T11:52:09+02:00Week-end de contribution à GrammalecteLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Grammalecte est un correcteur grammatical et typographique libre, pour la langue française uniquement, pour Writer (LibreOffice, OpenOffice), Firefox & Thunderbird, Chrome, etc. Il a déjà été évoqué de nombreuses fois sur LinuxFr.org :</p>
<ul>
<li>dépêches sur les campagnes de financement participatif <a href="//linuxfr.org/news/grammalecte-correcteur-grammatical">1</a> et <a href="//linuxfr.org/news/grammalecte-correcteur-grammatical-2">2</a>, avec le soutien de LinuxFr.org</li>
<li>journal évoquant sa <a href="//linuxfr.org/users/perger/journaux/le-mardi-14-juin-2018-est-un-jeudi">correction des dates</a>
</li>
<li>etc.</li>
</ul>
<p>L’équipe de modération du site LinuxFr.org utilise quotidiennement Grammalecte pour corriger les fautes de frappe, d’orthographe, de grammaire, de typographie ou de dates (ça arrive de temps en temps avec l’Agenda du Libre par exemple). Bref on aime Grammalecte.</p>
<p>Pour autant cela ne veut pas dire que tout est parfait dans ce logiciel : il est possible de l’améliorer en signalant les problèmes rencontrés, les erreurs non corrigées, les propositions de corrections erronées, etc.</p>
<p>Et c’est là que LinuxFr.org peut aider et contribuer : je vous propose durant ce week-end de contribuer à Grammalecte (et un peu à LinuxFr.org vu que ça peut nous aider à corriger des contenus au passage). Comment procéder :</p>
<ul>
<li>installer Grammalecte (dans votre navigateur sur ordinateur ou mobile)</li>
<li>allez sur la <a href="//linuxfr.org/redaction/news/depeche-collaborative-de-contribution-a-grammalecte">dépêche collaborative de contribution à Grammalecte</a>
</li>
<li>indiquer la page que vous êtes en train de faire relire par Grammalecte, en ajoutant la croix ✘ + votre pseudo après le lien de la page</li>
<li>ensuite venir noter les éventuels problèmes sur la page considérée</li>
<li>puis marquer la page comme relue en remplaçant la croix par une coche ✔</li>
<li>choisir une autre page et recommencer, jusqu’à épuisement du stock ou de votre motivation contributive</li>
</ul>
<p>(nb: il existe aussi <a href="//linuxfr.org/suivi/languagetool-style-and-grammar-checker">LanguageTool</a> mais nous ne l’utilisons pas pour LinuxFr.org actuellement)</p>
<div><a href="https://linuxfr.org/users/oumph/journaux/week-end-de-contribution-a-grammalecte.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/121208/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/oumph/journaux/week-end-de-contribution-a-grammalecte#comments">ouvrir dans le navigateur</a>
</p>
Benoît Sibaudhttps://linuxfr.org/nodes/121208/comments.atomtag:linuxfr.org,2005:Diary/386622019-09-12T19:18:23+02:002019-09-18T10:43:43+02:00Typographie et langues, mes ressources (quelques‑unes) à toutes fins utilesLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Cela devrait intéresser deux ou trois personnes ici, et comme ça, égoïstement, j’aurais tout sous la main d’un seul bloc aussi.</p>
<p>Donc mes références en typographie et en langue française accessibles sur Internet. Je mets de côté Wikipédia que tout le monde doit connaître ici. Plus une ch’tite astuce.</p>
<h2 id="toc-orthotypographie">Orthotypographie</h2>
<ul>
<li>les <a href="https://jacques-andre.fr/faqtypo/lessons.pdf">leçons de typographie</a> de Jacques André, PDF ;</li>
<li>
<a href="http://www.orthotypographie.fr/">Orthotypographie, orthographe & typographie françaises, dictionnaire raisonné</a> de Lacroux (hélas mort en 2002), site ;</li>
<li>le <a href="http://www.alain.les-hurtig.org/lacroux/lacroux.html"><em>Typographique Tombeau</em></a> de Lacroux, PDF ;</li>
<li>la rubrique <a href="http://www.plume-et-papier.com/typographie.php">typographie</a> du site <em>Plume et papier</em> ;</li>
<li>la <a href="http://listetypo.free.fr/">FAQ de la liste typographie</a> ;</li>
<li>le <a href="https://blog.mondediplo.net/histoire-d-o">blog du correcteur du <em>Monde diplomatique</em></a> ;</li>
<li>le site du <a href="http://typo.mondediplo.net/">code typo</a> (<em>Monde diplomatique</em>) ;</li>
<li>les <a href="http://www.axl.cefan.ulaval.ca/monde/regles-typo.htm">règles typographiques</a> du site L’aménagement linguistique dans le monde ;</li>
<li>le <a href="https://fr.wikisource.org/wiki/Auteur:Eug%C3%A8ne_Boutmy">Dictionnaire de l’argot de typographes</a> de Boutmy, à lire en ligne (Wikisources) ou télécharger, PDF, EPUB, mobi ;</li>
<li>la <a href="https://www.legifrance.gouv.fr/Media/Droit-francais/charte_typographique_jo_2016">charte typographique du JO</a>, PDF ;</li>
<li>le <a href="http://www.guide-typographie.com/">petit guide typographique</a>, site ;</li>
<li>
<em><a href="http://rondinet.free.fr/docs_fr_typo/fqblanc1.html">Les mots des blancs</a></em>, de Rondinet.</li>
</ul>
<h2 id="toc-langue">Langue</h2>
<ul>
<li>
<a href="https://www.oqlf.gouv.qc.ca/accueil.aspx">Office québecois de la langue française</a> ;</li>
<li>
<em><a href="http://www.langue-fr.net/">Langue-fr.net</a></em>, et notamment la page « <a href="http://www.langue-fr.net/Pour-une-redaction-epicene-prendre-en-compte-les-deux-genres-grammaticaux">Pour une rédaction épicène</a> » ;</li>
<li>le <a href="https://www.cnrtl.fr/definition/">dictionnaire du CNRTL</a> qu’on peut ajouter dans sa barre de recherche de Firefox ;</li>
<li>
<a href="http://latlntic.unige.ch/grammaticalite/">Grammalité et grammaire française</a>.</li>
</ul>
<h2 id="toc-chtite-astuce">Ch’tite astuce</h2>
<p>Petite astuce en passant si vous avez un environnement de bureau fonctionnant avec gtk,en utilisant le raccourci clavier Ctrl + Maj + U (lâcher les trois touches, taper le code, appuyer sur espace) et le code Unicode du caractère, vous pouvez saisir n’importe quel caractère et vous éviter, si vous n’êtes pas pro ou fan de la touche compose, de faire des allers et retours de haut en bas pour copier‐coller les caractères spéciaux de la syntaxe Markdown en bas de la page de saisie des journaux et dépêches.</p>
<p>Donc les plus utiles de mon point de vue, les autres sont sur le clavier (€, œ, Ê) ou on peut toujours aller chercher le code Unicode :</p>
<ul>
<li>fine insécable : 202f <code> </code> (elle figure ici devant les ponctuations hautes [?, !] et les points‐virgules) ;</li>
<li>guillemet ouvrant : ab <code>«</code> ;</li>
<li>guillemet fermant : bb <code>»</code> ;</li>
<li>apostrophe typographique : 2019 <code>’</code>.</li>
</ul>
<p>P.‐S. — Avec un clavier d’ordinateur sans pavé numérique, maintenez la touche majuscule enfoncée pour faire le code lorsqu’il contient des nombres.</p>
<div><a href="https://linuxfr.org/users/ysabeau/journaux/typographie-et-langues-mes-ressources-quelques-unes-a-toutes-fins-utiles.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118095/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/ysabeau/journaux/typographie-et-langues-mes-ressources-quelques-unes-a-toutes-fins-utiles#comments">ouvrir dans le navigateur</a>
</p>
Ysabeau 🧶 🧦https://linuxfr.org/nodes/118095/comments.atomtag:linuxfr.org,2005:Bookmark/7202019-06-27T07:49:21+02:002019-06-27T07:49:21+02:00Practical Typography<a href="https://practicaltypography.com/">https://practicaltypography.com/</a> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/117555/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/guillawme/liens/practical-typography#comments">ouvrir dans le navigateur</a>
</p>
Guillawmehttps://linuxfr.org/nodes/117555/comments.atomtag:linuxfr.org,2005:Diary/380542018-07-29T11:48:56+02:002018-08-11T20:44:13+02:00Fins de tabulation élastiques: la bonne manière d'indenter et d'aligner le codeLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Il y a des débats sans fin sur l'usage de tabulations ou d'espaces pour indenter et aligner son code. Chaque approche a ses avantages et des inconvénients, ses fidèles et ses ennemis.</p>
<p>(Indenter, c'est mettre de l'espace au début des lignes pour montrer visuellement les relations d'emboîtement logique des différentes lignes de code. Aligner, c'est mettre de l'espace avant un morceau de texte, pas forcément en début de ligne, pour créer un lien visuel entre plusieurs morceaux sur des lignes voisines qui est logiquement lié.)</p>
<p>L'approche des "fins de tabulations élastiques" (<em>elastic tabstops</em>) est clairement la meilleure solution à ce problème—j'explique en quoi elle consiste ci-dessous, je vous laisse vous convaincre que c'est la solution ultime. Elle a un seul défaut : elle n'est pas utilisable en pratique parce qu'elle n'est pas disponible dans les éditeurs que nous utilisons. C'est un défaut qui ne peut se régler qu'en communicant à son sujet pour que plus de gens y pensent et l'adopte, pour créer un environnement où elle est utilisable.</p>
<h4 id="toc-qui-quand">Qui, Quand</h4>
<p>Les tabulations élastiques ont été inventées en 2006 par Nick Gavgaard, et le document explicatif de référence (en anglais) est son site web, <a href="http://nickgravgaard.com/elastic-tabstops/">http://nickgravgaard.com/elastic-tabstops/</a>.</p>
<p>Il y recense aussi des plugins pour quelques éditeurs de texte (il maintient un plugin pour Visual Studio), mais les éditeurs libres sont assez mal lotis (Nick Gavgaard a écrit un plugin Gedit, mais il n'est pas maintenu et plus compatible avec des changements d'API). Il y a par contre des bibliothèques de formatage de texte qui ont adopté ce concept, par exemple le paquet <a href="https://golang.org/pkg/text/tabwriter/">tabwriter</a> de la bibliothèque standard Go.</p>
<h4 id="toc-quoi">Quoi</h4>
<p>La "fin de tabulation", c'est l'endroit où un éditeur de texte va mettre le curseur après l'usage d'un caractère de tabulation.</p>
<p>La façon standard de calculer, c'est qu'il met le curseur à la colonne dont le numéro prochain multiple de N, la "largeur de tabs" choisie par l'utilisateur. Typiquement N=8, donc si on n'a rien écrit et qu'on appuie sur tab on se retrouve à la colonne 8, et si on écrit un mot de 4 lettres (donc on est en 12) et qu'on ré-appuie sur tab, on se retrouve à la colonne 16.</p>
<pre><code>012345678901234567890123456789
\t foo\t bar
\t foo2\t baz
\t long word\t rest
</code></pre>
<p>Ça permet d'aligner facilement des fragments de texte… tant qu'ils font moins de 8 caractères. Mais dès qu'on dépasse 8 caractères, ou dès qu'on commence un peu trop près du prochain multiple de 8, c'est la galère. En pratique les gens s'entendent pour dire que si on veut utiliser des tabulations, il ne faut les utiliser qu'en début de la ligne (pour indenter), car en milieu de ligne c'est trop imprévisible, et aligner avec des espaces. Mais aligner, c'est joli et souvent utile, et avec des espaces c'est galère—sauf si notre éditeur a un mode spécial pour cela.</p>
<p>L'idée des "fins de tabulation élastique", c'est qu'au lieu de fixer pour chaque ligne la position des fins de tabulation, on les positionne en fonction des lignes adjacentes pour préserver l'alignement. Concrètement, si deux lignes sont adjacentes, on regarde combien de tabulation elles ont en commun (elles n'ont pas forcément le même nombre de tabulations), et on demande à ce que ces tabulations communes, comptées à partir du début de la ligne, soit alignées verticalement. Enfin, on demande une largeur minimale de blanc (choisie par l'éditeur ou l'afficheur de texte) pour chaque tabulation. Dans l'exemple précédent, si on demande une largeur minimale de 4 (par exemple), et qu'on écrit le texte ligne par ligne, on a d'abord</p>
<pre><code>012345678901234567890123456789
\t foo\t bar
</code></pre>
<p>puis on ajoute la deuxième ligne; la deuxième tabulation finit un peu plus loin (pour respecter la largeur minimale), donc la deuxième tabulation de la première ligne se décale aussi</p>
<pre><code>012345678901234567890123456789
\t foo\t bar
\t foo2\t baz
</code></pre>
<p>pareil, quand on ajoute la troisième, les fins de tabulations des deux premières lignes se décalent de façon élastique:</p>
<pre><code>012345678901234567890123456789
\t foo\t bar
\t foo2\t baz
\t long word\t rest
</code></pre>
<p>Pour la même chose en plus clair et plus joli, Nick Gravgaard a fait des animations plus visuelles:</p>
<p><img src="//img.linuxfr.org/img/687474703a2f2f6e69636b6772617667616172642e636f6d2f656c61737469632d74616273746f70732f696d616765732f636f6c756d6e626c6f636b735f636f6c6f757265642e676966/columnblocks_coloured.gif" alt="animation de tabulation élastique" title="Source : http://nickgravgaard.com/elastic-tabstops/images/columnblocks_coloured.gif"></p>
<div><a href="https://linuxfr.org/users/bluestorm/journaux/fins-de-tabulation-elastiques-la-bonne-maniere-d-indenter-et-d-aligner-le-code.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/114992/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/bluestorm/journaux/fins-de-tabulation-elastiques-la-bonne-maniere-d-indenter-et-d-aligner-le-code#comments">ouvrir dans le navigateur</a>
</p>
gaschehttps://linuxfr.org/nodes/114992/comments.atomtag:linuxfr.org,2005:Post/376022016-12-02T12:40:40+01:002016-12-02T12:40:40+01:00Gestion des espaces insécables dans Markdown<p>Bonjour à tous,<br>
je travaille pas mal avec le format Markdown et j'ai noté que je n'arrive jamais à voir mes ajouts d'espaces insécables respectés. J'ai beau ajouter manuellement le "U+00A0 NO-BREAK SPACE", si j'exporte ensuite vers un format quelconque avec pandoc, il n'en tient aucun compte. Je suis obligé de bidouiller en mettant des "& n b s p ;" partout, ce qui supprime l'aspect fluide du texte (je rédige des textes non techniques) et n'est pas compatible avec mon environnement de travail (relecture des textes par des bénévoles allergiques à la moindre balise).</p>
<p>Est-ce que certains ici se sont déjà penché sur cette question ? J'ai posé la question sur <a href="https://talk.commonmark.org/t/native-support-for-unicode-no-break-space/2251">le forum de CommonMark</a>, et pour eux le problème n'existe pas dans pandoc, ce serait donc en amont. Pour l'heure j'utilise Atom pour éditer mes textes, et les espaces insécables s'affichent bien quand j'ouvre le fichier, me semble-t-il (j'ai ajouté un plugin dédié pour cela).</p>
<p>Mes connaissances techniques étant limitées, je ne sais pas comment m'y prendre pour avoir une façon d'intégrer ces éléments importants de la typographie sans afficher ces horribles balises html. Peut-être aurez-vous des idées…</p><div><a href="https://linuxfr.org/forums/general-general/posts/gestion-des-espaces-insecables-dans-markdown.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/110682/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/general-general/posts/gestion-des-espaces-insecables-dans-markdown#comments">ouvrir dans le navigateur</a>
</p>
Yann Kervranhttps://linuxfr.org/nodes/110682/comments.atomtag:linuxfr.org,2005:Diary/360752015-08-28T15:47:10+02:002015-08-28T18:33:34+02:00Typographie & logicielsLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li>
<a href="#tour-dhorizon-des-logiciels">Tour d’horizon des logiciels</a><ul>
<li><a href="#la-garamond-une-police-qui-a-du-caract%C3%A8re">La Garamond, une police qui a du caractère</a></li>
<li><a href="#indesign-support-complet">InDesign, support complet</a></li>
<li>
<a href="#microsoft-office-version-r%C3%A9cente-indispensable">Microsoft Office, version récente indispensable</a><ul>
<li><a href="#word-2oo7">Word 2oo7</a></li>
<li><a href="#word-2o1o">Word 2o1o</a></li>
</ul>
</li>
<li><a href="#libreoffice-la-bonne-surprise">LibreOffice, la bonne surprise</a></li>
<li><a href="#scribus-en-net-d%C3%A9faut">Scribus, en net défaut</a></li>
<li><a href="#latex-la-rolls-royce">LaTeX, la Rolls-Royce</a></li>
</ul>
</li>
<li><a href="#et-le-web">Et le web ?</a></li>
</ul><p>Au départ ce devait être un journal. Mais je me suis dit « dommage de faire un truc sur la typo. sans la pratiquer », alors c’est devenu <a href="http://dl.free.fr/jxm5mMK5f">un PDF avec hyperliens</a>. Il n’est pas finalisé, mais est déjà très correct. Me connaissant j’en ai pour des mois pour lui apporter les perfectionnements nécessaires, alors je préfère en parler maintenant. Je mets ici une version légèrement remaniée de la partie finale du dossier, la plus susceptible d’intéresser le lectorat Linuxfr (le reste est une synthèse documentaire).</p>
<h2 id="tour-dhorizon-des-logiciels">Tour d’horizon des logiciels</h2>
<p>On pourrait penser qu’avec l’ordinateur, les possibilités illimités offertes et l’ancienneté des logiciels bureautiques, la typographie devrait être correctement traitée. Pourtant il n’en est rien, et il faut donc être attentif aux fonctionnalités disponibles. Il s’agira toujours de détails, mais c’est précisément ce genre de détails qui ruinent l’aspect professionnel d’un document; il ne sert à rien de prendre soin de la mise en page, si on ne dispose pas d’une minimum en typographie.</p>
<p>Le test est simple, il faut reproduire la phrase «Quel Test final?» afin de valider un ensemble de fonctionnalités. Les alternatives contextuelles servent à modifier le dessin d’un caractère en fonction de son environnement immédiat; ici la barre du Q doit passer sous le u. Le kerning est l’espacement entre caractères, ajusté non pas sur la base du caractère isolé, mais d’un couple; ainsi le e qui suit le T doit être légèrement déplacé à gauche afin de remplir l’espace laissé vacant en-dessous de la barre horizontale du T. Et enfin la présence de ligatures doit être assurée, les standards sont le minimum syndical, les plus rares permettront de rendre un texte à l’allure très soignée.</p>
<h3 id="la-garamond-une-police-qui-a-du-caractère">La Garamond, une police qui a du caractère</h3>
<p>À l’heure actuelle, on utilise surtout deux formats: TrueType Font, dépassé, et OpenType Font. On attend d’une police:</p>
<ul>
<li>outre l’esthétique du dessin des glyphes, l’homogénéité du style et le choix de la fonte en rapport avec le message écrit;</li>
<li>un kerning, ou crénage, correctement spécifié par le concepteur;</li>
<li>des ligatures, standards à minima;</li>
<li>des alternatives contextuelles;</li>
<li>au moins deux graisses (normal–regular et gras–bold) et une vraie italique, pas le résultat d’un déformation automatisée;</li>
<li>des petites capitales, car si on se contente de réduire les grandes capitales, on modifie la graisse de la fonte, donc le gris typographique; mais des graisses intermédiaires peuvent sauver la mise;</li>
<li>pour la même raison, les exposants et les indices devraient avoir leur propre dessin, plutôt qu’être le résultat d’un opération automatisée;</li>
<li>disposer de différentes fontes, applicables en fonction de la taille des caractères, car il faut affiner les traits des glyphes au fur et à mesure que leur taille augmente (optical size chez Adobe ou display, subhead, caption, etc.);</li>
<li>il faut savoir qu’il existe une version minuscule (utilisée ici), avec ses jambages, des chiffres arabes usuels, très utile dans un texte de fond.</li>
</ul><p>La <em>Garamond Premier</em> est une excellente police, avec une famille de fontes étendue et disposant de toutes les qualités. C’est une référence française, un temps éclipsée par des polices plus modernes, elle sort de l’ordinaire tout en restant traditionnelle, voir connote un certain luxe si toutes les ligatures et les alternatives sont en place (cf. collection la Pléiade). À contrario, je lui trouve un certain caractère, accusé par son âge, car elle me semble plus humaine que les didones, parce que moins raffinée en un sens. C’est cette tension entre deux aspects contradictoires qui me plaît.</p>
<h3 id="indesign-support-complet">InDesign, support complet</h3>
<p>Je me devais d’en parler étant donné que les outils Adobe, souvent associés aux Mac, sont très populaires parmi les graphistes et autres “créatifs”. Je me fie à la documentation… & on comprend mieux le succès d’Adobe, qui est aussi une fonderie numérique reconnue: support complet dès le début des années 2ooo; c’est durant cette période que la fonderie sort ses polices en version OpenType.</p>
<h3 id="microsoft-office-version-récente-indispensable">Microsoft Office, version récente indispensable</h3>
<p>Microsoft traîne quelques boulets avec la typographie; la fumeuse <em>Comic Sans</em> est une véritable catastrophe ambulante, l’<em>Arial</em> une vague copie de l’<em>Helvetica</em>. Il ne faut pas trop attendre d’une boite qui aura imposé sans effort un logiciel de traitement de texte d’une qualité pourtant médiocre. Même les dernières <em>Calibri</em> et <em>Cambria</em> ne me semblent pas très réussies: elles ont été manifestement et avant tout conçues pour l’informatique, pour mettre en avant la lisibilité sur écran avec le système ClearType; dans le détail, je les trouve très grossières. La <em>Garamond</em> livrée avec la suite de Microsoft ne déroge pas à la règle; elle ne supporte pas la comparaison avec la <em>Premier</em>; en fait, même la police libre <a href="http://www.georgduffner.at/ebgaramond/fr/index.html"><em>EB Garamond</em></a>, en cours de conception, me semble être de meilleure qualité.</p>
<h4 id="word-2oo7">Word 2oo7</h4>
<p>Il y a une case à cocher, intitulée crénage. Elle est désactivée par défaut; je suppose qu’il fallait assurer la compatibilité avec l’existant, car le crénage change la <a href="https://fr.wikipedia.org/wiki/Chasse_%28typographie%29">chasse</a> et donc la mise en page d’un document. Il faut donc penser à bien l’activer. Il n’y a aucune ligature; c’est impardonnable, rédhibitoire.</p>
<h4 id="word-2o1o">Word 2o1o</h4>
<p>Ici on trouve un formulaire complet là où il n’y avait que le crénage: choix des ligatures, choix des variantes contextuelles, de la forme des chiffres, etc. ainsi que les variantes stylistiques (une fonctionnalité OpenType).</p>
<p>Microsoft aura tardé l’implémentation des fonctionnalités typographiques de base d’un traitement de texte. & comme beaucoup de version 2oo7 courront encore dans les rue pendant un bout de temps, il ne faudra pas s’attendre à un résultat correct dans un proche avenir. Un comble alors que l’OpenType a été initié par eux. Enfin, avec l’éternelle promesse faite aux utilisateurs de simplicité et pour ne pas le brusquer, nul doute que peu prendront la peine de respecter les règles les plus élémentaires de typographie en faisant la démarche de s’y initier et d’activer les options nécessaires à un rendu de qualité minimale.</p>
<p><img src="//img.linuxfr.org/img/687474703a2f2f7069782e746f696c652d6c696272652e6f72672f75706c6f61642f6f726967696e616c2f313434303736353830342e706e67/1440765804.png" alt="Microsoft Word exemple" title="Source : http://pix.toile-libre.org/upload/original/1440765804.png"><br><em>La Garamond premier et la Garamond made in Microsoft respectivement. Avec le formulaire de typographie avancée.</em></p>
<h3 id="libreoffice-la-bonne-surprise">LibreOffice, la bonne surprise</h3>
<p>Mon test utilise une version à jour, 4.4.4.3. La police est traitée de manière correcte et tout est automatique. Manque la ligature rare, à ajouter à la main. Pour ne pas commettre les mêmes erreurs que Microsoft, il faudrait en plus de ce résultat, permettre à l’utilisateur de s’initier à la typographie, par exemple en lui laissant le choix d’un style “lecture sur écran” avec la police DejaVu, et un autre pour l’impression avec une police plus adaptée.</p>
<p>Le support a toujours structuré l’écriture et son dessin, avec l’outil utilisé: chute de poterie, argile (à laquelle l’écriture cunéiforme s’adapte), gravure sur pierre, bois y compris vivant — il suffit d’observer les troncs en ville pour se rendre compte que l’usage a perduré… —, papyrus, parchemins, qui sont éventuellement assemblés en codex, papiers (de riz, torchon, bible…) et support numérique. Il n’y a donc pas de raisons de s’en abstraire et en fonction de la destination du document, son auteur devrait pouvoir sélectionner la mise en page et la police les plus adaptées. La technologie css le permet pour le web. Les suites bureautiques devraient offrir à leurs utilisateurs le choix de la finalité de leur document et proposer la typographie qui convient en conséquence.</p>
<h3 id="scribus-en-net-défaut">Scribus, en net défaut</h3>
<p>Scribus gère mal le format OpenType, par chance j’ai pu choper une version TrueType de la fonte. En conséquence, sauf le kerning rien n’est automatique: il faut ajouter les ligatures à la main, idem pour l’alternative contextuelle. Bref, c’est faisable pour des textes très courts, mais ça devient vite pénible car il faut chercher dans la table des caractères et insérer manuellement.</p>
<p>Ce logiciel phare de la pao libre, que j’apprécie par ailleurs, est une déception. Cependant, il semblerait qu’il y ait un <a href="http://www.scribus.net/scribusctl-project-started/">travail</a> en cours et allant dans le bon sens.</p>
<h3 id="latex-la-rolls-royce">LaTeX, la Rolls-Royce</h3>
<p>Ici je triche un peu; pour ne pas me prendre la tête j’utilise LyX; en backend c’est XeTeX qui est à la manœuvre, car c’est celui qui a fourni le meilleur support des polices OpenType. Avec la police de caractère par défaut (Computer Modern) et LaTeX standard, le kerning est bon, et la ligature standard est automatique. Il y a probablement moyen d’activer la ligature rare. Resterait l’alternative contextuelle à tester, mais comme ce n’est pas le but du test, je poursuis.</p>
<p>En passant à XeTeX et la Garamond Premier, l’alternative contextuelle est bien là; la ligature rare est, quant à elle, désactivée par défaut. Dommage qu’il n’y ait pas une option directement proposée dans l’interface. Il faut personnaliser le préambule.</p>
<blockquote>
<p>\usepackage{microtype}<br>
\usepackage{fontspec}<br>
\setmainfont[Mapping=tex-text,Style=Swash,Numbers={OldStyle,Proportional},Ligatures={Rare,Historic}]{Garamond Premier Pro}</p>
</blockquote>
<p>Attention! les deux fonctionnalités numbers sont utiles pour utiliser des nombres dans un texte: elles permettent le bas de casse et un crénage des chiffres. Pour un texte à dominante mathématique, il est plus discutable de les activer, à mon humble avis. Ici ce n’est qu’un exemple à adapter à vos propres goûts: par exemple swash produit de très belles capitales italiques (si disponibles dans la police), à utiliser avec modération.</p>
<h2 id="et-le-web">Et le web ?</h2>
<p>Pour le web, ça ne m’intéresse pas trop. Il faut dire qu’en terme de mise en page c’est une catastrophe. Mais j’ai été agréablement surpris que Firefox gère assez bien les polices OpenType (ligatures standards, alternatives contextuelles activées par défaut). Voici un <a href="http://blog.typekit.com/2014/02/05/kerning-on-the-web/">billet</a> qui peut servir de point de départ dans le domaine.</p><div><a href="https://linuxfr.org/users/nicolasg/journaux/typographie-logiciels.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/106629/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nicolasg/journaux/typographie-logiciels#comments">ouvrir dans le navigateur</a>
</p>
NicolasGhttps://linuxfr.org/nodes/106629/comments.atomtag:linuxfr.org,2005:News/352952014-04-22T21:46:36+02:002014-05-11T16:29:15+02:00Prototypo, ou comment devenir typographe en quelques clicsLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<div><p>Qui n’a jamais été dans la situation où il ne trouvait pas exactement la police d’écriture qu’il cherchait, et surtout compatible multi‐supports, multi-applications ? Malgré le nombre de polices disponibles (gratuites ou non), il y a souvent un détail qui vient entacher un choix. Malheureusement, la création d’une nouvelle police n’est pas chose aisée, car cela demande de suivre un minimum de règles typographiques afin d’éviter certaines catastrophes visuelles…</p>
<h3 id="campagne-de-financement">Campagne de financement</h3>
<p>Imaginez donc une application « WYSIWYG » (<em>What You See Is What You Get</em>) vous permettant de jouer au typographe en herbe sans avoir à vous soucier des bases de la typographie, le tout pouvant être exporté sous différents formats : c’est ce que propose <a href="http://www.prototypo.io/"><em>Prototypo</em></a>.</p>
<p>Le projet, actuellement en phase de développement, a lancé le 9 avril dernier une campagne de financement participatif sur <a href="https://www.kickstarter.com/projects/599698621/prototypo-streamlining-font-creation">Kickstarter</a> afin d’accélérer son développement, ainsi que prendre la température sur les fonctionnalités les plus attendues par la communauté.</p></div><ul><li>lien nᵒ 1 : <a title="http://www.prototypo.io/" hreflang="en" href="https://linuxfr.org/redirect/90170">Site officiel Prototypo</a></li><li>lien nᵒ 2 : <a title="https://www.kickstarter.com/projects/599698621/prototypo-streamlining-font-creation" hreflang="en" href="https://linuxfr.org/redirect/90171">Campagne Kickstarter</a></li><li>lien nᵒ 3 : <a title="https://github.com/byte-foundry/prototypo" hreflang="en" href="https://linuxfr.org/redirect/90172">Dépôt GitHub</a></li><li>lien nᵒ 4 : <a title="https://vimeo.com/91306872" hreflang="fr" href="https://linuxfr.org/redirect/90173">Vidéo de présentation</a></li></ul><div><p>Prototypo est un projet libre sous licence AGPL dont le but est de fournir une application en ligne permettant de contrôler la conception d’une police à l’aide d’un large choix de paramètres typographiques (plus d’une vingtaine), afin de gérer la forme des lettres, le tout avec sa souris, simplement.</p>
<p>Yannick Mathey (le _designer_) et Louis‐Rémi Babé (le codeur) utilisent des technologies standard (HTML 5, CSS 3, SVG et JS) pour réaliser cette application dont le code est mis à disposition sur <a href="https://github.com/byte-foundry/prototypo">GitHub</a>.</p>
<p>Encore en phase bêta, Prototypo a besoin d’autres logiciels pour convertir les polices du format SVG vers OTF. La campagne Kickstarter vise justement à plus d’autonomie (entre autres). Le développement est plutôt actif, le <em>chat</em> des auteurs <a href="http://blog.prototypo.io/">se charge de la communication</a>.</p>
<p>Il est aussi à noter qu’une partie du financement sera reversé à d’autres projets libres contribuant au développement : un juste retour à la communauté, selon l’équipe de Prototypo.</p>
<p>En à peine une dizaine de jours, le projet a déjà atteint son deuxième objectif. Il lui reste jusqu’au 10 mai prochain pour le troisième. Alors, c’est français, c’est libre, et en plus ça facilitera la vie de beaucoup ; donc, pourquoi ne pas supporter cette initiative !</p></div><div><a href="https://linuxfr.org/news/prototypo-ou-comment-devenir-typographe-en-quelques-clics.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/101945/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/prototypo-ou-comment-devenir-typographe-en-quelques-clics#comments">ouvrir dans le navigateur</a>
</p>
NickZeroHeureDavy Defaudbubar🦥Xavier TeyssierNÿcoBruno MichelBenoît Sibaudhttps://linuxfr.org/nodes/101945/comments.atom