# Comment créer un langage XML et son éditeur en 5 minutes

## Introduction

Cette documentation explique comment créer un fichier de configuration pour Jaxe incluant le langage XML, la définition des menus d'insertion des éléments XML, et la méthode d'affichage des éléments. Il donne aussi un exemple de feuille de style XSLT. L'exemple donné a permis de créer avec Jaxe ce fichier que vous êtes en train de lire.

## Création du fichier de configuration de Jaxe

Les fichiers de configuration se situent dans le dossier `config` de Jaxe, et leur nom se termine en `_config.xml`. Par exemple, le fichier de configuration des fichiers de configuration (dont l'élément racine est CONFIG_JAXE), se nomme CONFIG_JAXE_config.xml. On commence donc par lancer Jaxe, choisir le bouton "Nouveau" et sélectionner "CONFIG_JAXE - Fichier de configuration de Jaxe".

Il existe deux options possibles pour la création d'un fichier de configuration de Jaxe:

- Utiliser un fichier de schéma XML pour définir le langage XML à utiliser, et définir juste les menus et la méthode d'affichage des éléments dans le fichier de configuration. Dans ce cas il est possible de créer automatiquement un début de fichier de configuration à partir du schéma, en ouvrant le fichier du schéma dans Jaxe et en utilisant le menu d'exportation.
- Définir un langage XML en utilisant une syntaxe simplifiée à l'intérieur du fichier de configuration.

On utilisera ici la syntaxe simplifiée, qui se contente de définir les éléments, leurs attributs, les sous-éléments, et quels éléments peuvent contenir du texte. Si on utilisait un schéma XML, il faudrait à la place simplement faire un lien vers le fichier du schéma.

## Définition du langage XML

On commence la définition du langage XML de la configuration en insérant un élément `Langage` sous `Configuration Jaxe`. A l'intérieur de l'élément `Langage`, on choisit d'insérer un `Schéma simple` pour pouvoir définir le langage XML dans le fichier de config.

Il faut alors définir tous les éléments du langage XML. Commençons par l'élément racine, que l'on appelera `DOCUMENTATION`. On insére un élément `Elément` sous `Schéma simple`, en donnant son nom et en spécifiant qu'il ne peut pas contenir de texte (d'autres sous-éléments pourront contenir du texte, mais pas l'élément racine) (attention à ne pas mettre d'espace dans les noms d'éléments).

On indique ensuite quels éléments seront autorisés sous `DOCUMENTATION`. En l'occurence, on prévoit déjà l'ajout des éléments `TITRE` et `SECTION`, dont on peut ajouter la référence sous forme de sous-éléments.

Ces éléments `TITRE` et `SECTION` doivent maintenant être définis. On procède de la même façon, en autorisant le texte sous `TITRE` mais pas sous `SECTION`.

Voilà la liste des éléments que l'on va définir, avec les sous-éléments autorisés :

- `DOCUMENTATION`
  - `TITRE`
  - `SECTION`
- `TITRE`
- `SECTION`
  - `TITRE`
  - `PARAGRAPHE`
  - `LISTE`
  - `IMAGE`
- `PARAGRAPHE`
  - `TITRE`
  - `EMPHASE`
  - `CODE`
  - `LIEN`
- `LISTE`
  - `EL`
- `EL`
  - `LISTE`
  - `EMPHASE`
  - `CODE`
  - `LIEN`
- `IMAGE`
- `EMPHASE`
- `CODE`
- `LIEN`

Certains éléments auront des attributs, que l'on définira à chaque fois avec l'élément `Attribut`.

- `IMAGE` aura un attribut `fichier` (obligatoire) pour spécifier le fichier de l'image.
- `LIEN` aura un attribut `href` (obligatoire) avec l'URL du lien.

Le texte sera autorisé sous : `TITRE`, `PARAGRAPHE`, `EL`, `EMPHASE`, `CODE` et `LIEN`.

Pour éviter de répéter les élément mélangés au texte à la fois dans `PARAGRAPHE` et dans `EL`, on pourra définir un ensemble contenant les éléments `EMPHASE`, `CODE` et `LIEN`, et indiquer cet ensemble comme sous-ensemble dans les éléments `PARAGRAPHE` et `EL`.

On peut remarque à ce point que l'élément `Langage` s'affiche en orange dans Jaxe, ce qui signifie qu'il n'est pas valide. En effet, il est obligatoire de spécifier au moins un élément racine possible pour le langage (ceci est obligatoire même quand on a spécifié un fichier de schéma XML WXS au lieu de définir un langage simplifié). Dans notre exemple, la racine est `DOCUMENTATION`. On l'indique avec l'élément `Racine` dans le fichier de config, juste après `Schéma simple`.

Voilà ce que donne la définition du langage XML dans Jaxe à ce point :

## Un éditeur moyen...

Une fois le langage défini, on peut déjà éditer des documents avec dans Jaxe... mais l'interface d'édition n'est pas terrible : il n'y a pas de menu pour le langage, tous les éléments sont affichés de la même façon, etc...

La différence entre Jaxe et un éditeur quelconque est justement qu'il est possible de configurer l'interface pour le langage XML choisi. C'est ce qui vient dans les étapes suivantes.

Si vous êtes arrivé jusque là, vous pouvez quand même déjà faire un essai : choisissez le menu "Ouvrir la configuration..." dans Jaxe, et sélectionnez votre nouveau fichier de config (une autre manière de faire est de placer le fichier de config dans le dossier `config`, de faire "Nouveau...", et de sélectionner la racine `DOCUMENTATION`). Les 3 panneaux de gauche fonctionnent déjà : on voit la liste des éléments que l'on peut insérer à un endroit donné, l'arbre du document et les attributs de l'élément courant. On peut aussi insérer des éléments avec le menu contextuel.

## Définition des menus

Lorsque l'on commence à avoir de nombreux éléments dans le langage, il devient important de les organiser pour pouvoir insérer les éléments plus facilement qu'à partir d'une liste de 100 éléments dans l'ordre alphabétique : c'est l'objectif des menus d'insertion dans Jaxe.

On va préparer des menus d'insertion pour tous les éléments du langage (à part la racine qui est automatiquement ajoutée aux nouveaux documents), en les organisant dans 3 menus : Organisation, pour l'organisation du document, Blocs pour les éléments de bloc (qui ne sont pas mélangés avec du texte), et Texte pour les éléments que l'on peut mélanger avec du texte. On peut en profiter pour spécifier des raccourcis clavier pour insérer très rapidement des éléments que l'on utilise fréquemment : p pour `PARAGRAPHE`, et t pour `TITRE`.

Voilà ce que ça donne :

## Affichage des éléments

Cette section est peut-être la plus importante dans Jaxe : il s'agit de définir la façon dont les éléments vont être affichés et édités dans Jaxe. Il existe un certain nombre de types d'affichage, définis en détail dans la documentation sur la syntaxe. Le type d'affichage par défaut est `string` : il affiche juste une balise de début et une balise de fin pour entourer le contenu de l'élément, sans aucune indentation automatique.

Voilà quelques types d'affichage que l'on peut choisir pour notre exemple :

- `DOCUMENTATION` : `division`
- `TITRE` : `string`
- `SECTION` : `division`
- `PARAGRAPHE` : `zone`
- `LISTE` : `liste`
- `EL` : `item`
- `IMAGE` : `fichier`
- `EMPHASE` : `string`
- `CODE` : `string`
- `LIEN` : `string`

Le type `fichier`, par exemple, permettra l'affichage automatique de l'image pointée par l'élément `IMAGE`. Pour que Jaxe sache quel attribut pointe vers le fichier, il faut cependant ajouter un paramètre à l'affichage d'élément : en l'occurence, il faut utiliser un paramètre avec le nom `srcAtt` et la valeur `fichier` (le nom de l'attribut de `IMAGE` qui pointe vers le fichier).

D'autres paramètres peuvent être utilisés pour obtenir une interface d'édition agréable : "`style`" "`GRAS`" pour l'élément `TITRE`, "`style`" "`ITALIQUE`" pour l'élément `EMPHASE`, et "`police`" "`MONOSPACED`" pour l'élément `CODE`.

Voilà comment cette partie de la configuration apparaît dans Jaxe :

## Exports

Tout ceci permet de faire de beaux fichiers XML, mais ils ne sont pas très utiles en tant que tels. Il reste donc à les exporter vers d'autres langages, en particulier HTML pour pouvoir obtenir des pages web. Pour cela, on ajoute au fichier de config un élément `Exports` qui contient un `Export` avec la sortie `HTML`. A l'intérieur, on pointe vers un fichier XSL qui défini la transformation depuis notre langage vers HTML. Ce fichier XSL peut être créé avec Jaxe, à partir de la config "XSLT" (voir plus loin comment faire).

L'ajout d'un export HTML dans la config provoquera l'activation du menu Fenêtre HTML dans le menu Fenêtres de Jaxe. La transformation sera effectuée à chaque fois que le menu sera invoqué, et à chaque fois qu'une mise à jour sera demandée par l'utilisateur.

## Textes

L'interface obtenue à ce point est utilisable, mais on peut souhaiter aller plus loin avec les textes affichés, pour :

- choisir un texte affiché dans le dialogue "Nouveau" de Jaxe
- changer les titres des menus
- changer les titres des éléments sur les balises quand ils sont affichés dans Jaxe
- ajouter une documentation pour chaque élément, facilement accessible pour les utilisateurs
- changer les titres pour les valeurs d'attributs
- faire tout ceci dans plusieurs langues sans avoir à changer le schéma (la langue étant choisie automatiquement pour l'utilisateur en fonction de la langue sélectionnée dans son système d'exploitation)

Tout ceci peut se faire avec l'élément `Textes`. Dans cet exemple, on se contentera juste de définir un petit texte affiché dans le dialogue de création d'un nouveau document, avec `Description de la config`.

## Fichier de l'exemple

Voici le fichier de configuration complet : DOC_config.xml.

Si l'on avait utilisé un fichier de schéma XML séparé du fichier de configuration Jaxe, il aurait fallu donner le chemin vers le fichier avec l'élément `Fichier du schéma XML` au lieu d'utiliser `Schéma simple`.

Voici le même exemple, en utilisant un fichier de schéma XML séparé du fichier de configuration Jaxe : DOC2_config.xml - DOC2.xsd.

## Création de la feuille de style

On crée un document XSLT en choisissant le menu "Nouveau" et en choisissant "stylesheet - XSLT". Les fichiers XSLT mélangent plusieurs langages XML dans un document. On voit donc ici des menus pour XSLT et des menus pour XHTML.

Il faut commencer par préciser la version de XSLT que l'on utilise en mettant la valeur "1.0" à l'attribut `version` de la racine. On précise ensuite quelle sortie on veut obtenir pour la transformation. Par exemple, pour obtenir du XHTML, on utilise `xsl:output` avec les attributs :

- `doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"`
- `doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"`
- `encoding="ISO-8859-1"`
- `indent="yes"`
- `method="xml"`

De manière générale, il suffit ensuite d'indiquer pour chaque élément un équivalent HTML. Par exemple, pour que `CODE` soit affiché comme avec `tt` en HTML, on utilise un élément `template` de XSLT avec la valeur "CODE" pour l'attribut `match`, et on place à l'intérieur l'élément `tt` de HTML, en appliquant récursivement les autres règles à l'intérieur avec l'élément `apply-templates` de XSLT :

Voilà le fichier XSL terminé.

## Top chrono!

Finalement, il ne reste plus qu'à choisir le menu "Ouvrir la configuration..." et choisir notre fichier de configuration, `DOC_config.xml`, pour créer un nouveau document avec. On peut aussi placer le fichier de configuration dans le dossier `config` de Jaxe (avec les fichiers associés) afin qu'il apparaisse dans la liste quand on crée un nouveau document avec le menu "Nouveau".