Infini-62

• Créer une fonte sans capitales/bas-de-casse et sans chiffres
• Penser une collection de signes/formes, un ensemble cohérent
• Imaginer leur comportement, les relations de ces formes entre elles/avec des lettres ou d’autres glyphes.

Je pensais à créer une fonte où on ne peut pas effacer à proprement dit ce que l’on a écrit. Où quand on tape sur le retour arrière/backspace, au lieu de supprimer les glyphes précédents ça les “barre” ou les “rature”.

L’idée était de montrer le processus de réflexion lorsqu’on écrit, de ne pas pouvoir cacher ses hésitations, de ne pas pouvoir polir le texte. Quand on lit un texte on ne sait pas si la personne qui l’a écrite a recommencé 20 fois une phrase ou bien a écrit ce paragraphe entier sans hésitation, et ce projet de fonte pourrait s’inscrire dans une matérialisation de ce processus d’écriture/réécriture.

Mais en fait c’est pas vraiment possible de faire ça dans la fonte même parce que la touche backspace n’est pas encodable, on ne peut pas appliquer de forme dessus (et donc d'OpenType Features dessus).

J’ai quand même envie de réfléchir que l’aspect que ça pourrait prendre, quitte à “tricher” par la suite pour la mise en application dans le contexte imaginé. J’essaye de trouver des formes à ces ratures (applicables manuellement) :

• des gribouillis, quand on est énervé·e ?
• des tâches, quand c’est un accident (faire baver la fonte) ?
• une simple ligne, quand on est pas sûr·e ?
• un gros bloc, quand on veut du secret ?
• un trait souple, quand on est rapide ?
• un motif, quand on est sophistiqué·e ?
• des lettres qui se superposent, quand on aime les machines à écrire ?
• des signes comme dans les BD, quand on est pas vulgaire ?

Pour essayer d’imiter mon idée de départ j’ai fait une rapide interface avec javascript qui me permet de voir à quoi ressemblerait un texte écrit avec le protocole imaginé. Une fois que j’aurais quelques fontes-test je pourrais les intégrer à cette interface.

Pour tester la dernière version en date, c’est par là.

Ça fonctionne avec javascript, et il y a deux parties :

• Une partie où on tape le texte
• Une partie où le texte s’affiche (et garde en mémoire ce qui a été effacé)

Pour faire ça je pensais au début afficher dans la deuxième partie les touches tapées dans la première, mais en fait ce système capture toutes les frappes (ça écrit le texte “Shift” ou “Control” ou “Backspace” au milieu du texte, ce qui n’est pas pratique).

Une méthode plus simple serait d’afficher dans la deuxième partie seulement les caractères effectivement écrits dans la première (ce qui enlèverait les touches invisibles/de composition comme Shift). Dès que javascript reconnaît qu’une lettre a été écrite, il la copie dans la deuxième partie. Ça fonctionne beaucoup mieux mais j’ai toujours un problème avec les capitales accentuées. Si je veux écrire  avec mon clavier (ordi portable sous GNU/Linux) je dois taper ^ puis Shift+A, mais alors le A est reconnu comme la touche Process (un caractère combiné). Et cette touche n’est pas reconnue comme tapée, il faut donc que je le “force” dans le code.

J’ai aussi rajouté une fonction pour enregistrer le texte obtenu avec les parties raturées entourées de balises HTML <span>, comme ça on peut voir ce texte “complet” sur d’autres logiciels (on peut l’utiliser sur une page web en appliquant une classe aux spans ou alors appliquer un style de caractères à ce qui se trouve dans la balise sur InDesign.

Pour rendre la fonte un peu plus “automatique”, je pense ajouter un jeu stylistique raturerait le texte grâce à des substitutions OpenType. La largeur des ratures est calculée en prenant la moyenne de la largeur des glyphes de la fonte.

Je ne sais pas si je prends tous les glyphes en compte ou bien seulement les lettres/chiffres, la ponctuation pouvant biaiser le résultat. Je pourrais aussi calculer la récurrence de certaines lettres/caractères en français pour avoir une estimation plus en accord avec ce qui sera tapé au final (la largeur du e a plus d’impact sur la moyenne que celle du k).

Pour importer les SVG dans une PUA j’ai modifié un script de Luuse en python.

Chaque mot est barré par une ligne diagonale, qui est en fait un glyphe différent.
On remplace le mot carotte par carotte+rature où rature est un glyphe de la longueur de 7 caractères (la longueur du mot carotte), avec une largeur nulle et une approche gauche égale à 7 caractères moyens (7 fois la largeur moyenne).

J’ai d’abord dessiné sur Inkscape, en utilisant l’extension exportobjects pour les exporter dans des fichiers séparés. Le problème c’est que quand je veux les importer par la suite dans FontForge il y a un problème de viewBox/viewport, alors le logiciel réduit la taille du SVG pour le faire rentrer dans une seule “case” de la fonte.

Je suis donc passé sur Illustrator pour tirer parti des plans de travail et pouvoir enregistrer plusieurs SVG en même temps tout en contrôlant que la dimension de chaque fichier reste cohérente avec la taille du cadratin de la fonte.

Je suis arrivé à faire un prototype qui fonctionne avec les features, mais il est assez limité. Il y a des problèmes de caractères pas bien reconnus selon leur place dans le mot, et aussi le problème de la largeur moyenne des glyphes (calculée uniquement sur la chasse des bas-de-casse).

Si je devais faire aboutir le prototype il faudrait que je pondère la chasse de chaque caractère par sa récurrence dans un texte d’une langue donnée. La chasse du e ou du i a plus d’importance que celle du w quand on cherche la largeur moyenne/approximative d’un mot de 5 ou 7 lettres.

Techniquement la substitution pose aussi problème, car je substitue la ponctuation après un mot par un glyphe de la largeur de ce mot, ce qui fait qu’on perd la ponctuation dans l’affaire. Ça pourrait se résoudre en bidouillant encore pas mal (en faisant des substitutions en plusieurs parties par exemple).

Enfin l’aspect des barres est assez sommaire et pourrait être travaillé pour ajouter plus de variété et de personnalité (appliquer des styles de tracés dans Illustrator ou Inkscape).

On remplace le mot carotte par c\a\r\o\t\t\e\ où \ est un glyphe qui fait une tâche sur le caractère précédent (largeur nulle et approche gauche égale à la largeur moyenne).

J’ai d’abord dessiné ces formes à la main avec plusieurs outils (stylo, marker…) pour les vectoriser sur Inkscape par la suite. La question des dimensions à l’import est toujours là. C’est compliqué de prévoir où va se situer le glyphe une fois le SVG importé par le script dans FontForge sans le positionner en avance dans un cadre de la taille estimée (largeur moyenne + hauteur du cadratin de la fonte).

J’ai choisi les “taches” sur chaque caractère car ça permettait plus de variété (je peux faire un set stylistique pour chaque ensemble de taches) et c’est un peu plus simple à implémenter (moins de prises de tête avec les features). Mon intérêt dans le projet vient aussi des différentes raisons pour lesquelles on peut supprimer du texte (une faute de frappe, la honte, un changement d’avis, une précision, l’humeur du moment) qui impliquent différentes formes de ratures dans un texte manuscrit.

Pour affiner un peu la substitution je crée grâce à un script des classes de caractères de 60 unités, ce qui me permet de regrouper les lettres qui ont des largeurs similaires (le a, le e, le o et le c ou le M et le W par exemple). Ensuite j’essaie de faire la même chose dans les ensembles de svg pour avoir des largeurs plus cohérentes.