Chapitre 4 : Les feuilles de style

XSL (eXtended Stylesheet Language) et CSS (Cascading StyleSheets) sont deux outils apparemment redondants mais en réalité très complémentaires.

CSS est apparu en 1997 et proposait de dissocier la mise en page du contenu du document HTML. Il introduisait entre autres, dans la version 2, la notion de type de média permettant de gérer des mises en pages différentes en fonction du média (imprimante, écran, ...). Par contre elle n'est supportée que par les dernières versions des navigateurs.

XSL est le format de feuille de style défini pour les documents HTML. Il offre des fonctionnalités similaires à CSS en y ajoutant d'autres fonctionnalités dont la transformation de données. Malheureusement XSL n'est pas encore totalement supporté par les navigateurs, y compris les dernières versions.

De fait aujourd'hui, si l'on souhaite malgré tout utiliser les feuilles de styles XSL sans pour autant être contraint par les limites des navigateurs actuels, il est possible d'opérer la mise en forme sur le serveur et de générer un document au format HTML qui sera envoyé au navigateur.

2. XSL

2.1. Présentation

o XSLT (XSL Transformation) pour le parcours et la transformation d'un document source XML vers un autre document XML,

Au départ, il n'y avait pas cette séparation, et c'est pourquoi le terme générique XSL désigne aussi bien la phase de transformation que celle de formatage.

2.2. XSL et le W3C

XSLT 1.0 et XPATH 1.0 ont un statut de recommandation du 16 Novembre 1999, dont les spécifications sont disponibles à :

XSL, qui contient la partie XSL-FO, a un statut de recommandation du 21 Novembre 2000, dont les spécifications sont disponibles à :

La feuille XSL est donc la feuille de style associée au document XML. Elle contient les règles de transformation, de présentation et de mise en forme des données.

La feuille XSL intègre des fonctionnalités plus puissantes que la feuille de style CSS. Elle permet en effet de préciser des règles d'enchaînements, des conditions, des calculs, etc. .

3. XSLT: LA TRANSFORMATION

XSLT (XML Stylesheet Language Transformation) a pour objectif de définir un langage pour effectuer des transformations sur des arbres XML.

La transformation produit en sortie un fichier XML de préférence XHTM, WML, SVG, ...

XSLT permet de gérer, a partir d'une source unique d'informations, des fichiers adaptés aux différents canaux de visualisation (PC, Mobile, WebTV, … )

3.1. Document régulier versus document non régulier

Nous pouvons distinguer, de part leur nature et leur traitement spécifique en XSLT, la notion de document régulier ou non régulier.

- Leur structure est constituée d'une imbrication arbitraire d'un ensemble d'éléments

3.1.1 Document régulier

3.1.2 Document non régulier

3.2. Le document XSLT et son référencement

Une feuille de style XSLT est un document XML qui commence par l'en-tête XML délimitée par : <xsl:stylesheet> ... </xsl:stylesheet>

Comme IE5 est basé sur le Working Draft de XSL, certaines incompatibilités avec la recommandation peuvent être rencontrées (pas de règles implicites, extensions propres à Microsoft) et le référencement en est différent.

Une feuille de style XSLT peut-être associée à un document XML à l'aide d'une instruction de traitement XML particulière

Les parseurs XML reconnaissent cette instruction et provoquent, lors du parsing du document XML, l'appel du processeur de transformation s'il existe.

Les parseurs XML reconnaissent cette instruction et provoquent, lors du parsing du document XML, l’appel du processeur de transformation s’il existe.

3.3. Les règles de transformation

Les feuilles de styles XSLT sont fondées sur des structures nommées modèles (templates). Un template précise ce qui doit être recherché dans l'arbre source, et ce qui doit être placé dans l'arbre résultat, la transformation.

Tout ce qui n'est pas préfixé par <xsl : …>, est généré tel que dans l'arbre résultat, d'où le processus de transformation.

Match est une expression de sélection de nœuds sur lesquels s'applique la règle. Elle peut-être exprimée en XPath, dont voici quelques exemples :

repertoire//fichier tous les éléments <fichier> avec <repertoire> comme ancêtre

3.4. Sélection de règle et parcours de l'arbre

Le processeur de transformation recherche les règles qui correspondent au nœud courant (match) et en cas de multiples règles, le processeur choisit la plus prioritaire.

Les processeurs réagissent différemment si deux règles peuvent s'appliquer à un nœud.

Le parcours de l'arbre est réalisé au travers de l'ordre <xsl:apply-templates> qui sélectionne les descendants du nœud courant avec lesquels le traitement continue.

L'élément <xsl:apply-templates> permet de descendre dans l'arbre, en précisant au processeur de traiter les éléments fils du nœud courant.

L'attribut select permet de décrire, comme l'attribut match de l'élément <xsl:template>, une expression XPath afin de restreindre le traitement aux nœuds enfants. Sans attribut select, tous les sous-éléments, les textes et commentaires sont sélectionnés.

L'élément <xsl:value-of select= "expression"> récupère la valeur d'un objet en entrée, pour la renvoyer en sortie.

Les processeurs XSLT ont deux règles implicites pour garantir le parcours récursif de l'arbre et la production des nœuds texte en l'absence de règle applicable à ce nœud.

Ces règles implicites doivent être écrites explicitement pour les transformations basées sur MSXML 1 &2 (WD).

3.5. La génération de noeuds

Pour générer un élément et ses attributs, il faut utiliser les mots suivants :

Pour générer les objets autres que les éléments XML, il faut utiliser les éléments suivants :

Par défaut, <xsl:text> préserve les espaces en sortie et permet de transformer ou non, en fonction de l'attribut 'disable-output-escaping', les méta-caractères & et < en '&' et '<'.

XSLT permet de copier un nœud de l'arbre source vers l'arbre destination par <xsl:copy>. Si l'on référence un attribut, il y a copie de son nom et sa valeur.

Les attributs de l’élément et ses nœuds fils ne sont pas copiés implicitement.

3.6 Fusion de feuilles de styles

XSLT permet de traiter, comme pour les DTD et XML Schema, la modularisation des feuilles de styles par deux techniques

<xsl:import> doit être en tête des instructions xsl après <xsl:stylesheet>

- <xsl:include > pour inclure, à l'endroit où cette instruction apparaît, la feuille de style référencée par l'attribut

<xsl:include> peut être n'importe où au premier niveau, mais après <xsl:import>

3.7. Format de sortie

XSLT permet de spécifier le format de sortie pour le document produit par le processeur <xsl:output > avec comme attributs :

- doctype-public = "FPIFichierDTD" pour générer une instruction <!DOCTYPE ... PUBLIC "FPIFichierDTD">

- doctype-system = "URIFichierDTD" pour générer une instruction <!DOCTYPE SYSTEM "URIFichierDTD">

- html : pour du HTML classique avec la possibilité de générer'<' pour javascript sans le remplacer par l'entité &It;

3-8 Récapitulation (partielle) des éléments de base de la syntaxe XSLT[4]

Une feuille de style XSL est un document XML dont l'élément racine est xsl:stylesheet

Règles "chablon" <xsl:template match="Critère"> ... </xsl:template>	stipule ce qui doit être produit en sortie pour tout élément du document XML qui correspondrait au critère indiqué par l'attribut match. Ce qui se trouve entre la balise d'ouverture et la balise de fermeture de l'élément xsl:template servira à produire la sortie correspondant l'élément XML qui aura satisfait au critère indiqué. Le critère peut être plus ou moins précis et correspond à un sous-ensemble de la spécification XPath. Si l'élément auquel s'applique ce chablon contient des sous-éléments qui doivent eux aussi être traités, il faudra imbriquer une règle xsl:apply-templates à l'intérieur de l'élément xsl:template.
<xsl:apply-templates />	stipule que toutes les règles portant sur des sous-éléments de l'élément courant doivent être appliquées.
<xsl:apply-templates select="Critère" />	stipule que, parmi les règles portant sur des sous-éléments de l'élément courant, seules doivent être appliquées celles qui portent sur les sous-éléments correspondants au critère indiqué.
<xsl:for-each select="Critère"> ... </xsl:for-each>	permet une itération sur tous les éléments satisfaisant le critère indiqué. Le contenu de l'élément xsl:for-each doit stipuler ce qui doit être produit pour chaque occurrence d'éléments sélectionnés.
<xsl:value-of select="Critère" />	produit en sortie le contenu de l'élément stipulé par le critére. Si l'attribut select est omis, c'est l'élément courant qui est utilisé. xsl:value-of est généralement utilisé quand le contenu de l'élément sélectionné est du texte simple.
<xsl:copy> ... </xsl:copy>	produit en sortie un élément de nom identique à l'élément courant, mais sans y mettre encore de contenu ou d'attributs. Le contenu de l'élément xsl:copy doit donc stipuler comment le contenu de l'élément de sortie doit être "rempli". Cela sera typiquement fait avec <xsl:apply-templates /> Cet élément est pratique à utiliser quand on utilise dans le document XML des éléments dont le nom correspond à des balises HTML.
<xsl:if test="ExpressionBooléenne"> ... </xsl:if>	exécute les règles imbriquées dans l'élément xsl:if uniquement si l'expression booléenne fournie est évaluée à vrai.
<xsl:choose> <xsl:when test="ExpressionBooléenne"> ... </xsl:when> <xsl:when test="ExpressionBooléenne"> ... </xsl:when> <xsl:otherwise> ... </xsl:otherwise> </xsl:choose>	fonctionne d'une manière similaire au xsl:if, mais permet de tester plusieures conditions et de prévoir une alternative quand toutes les conditions échouent.
<xsl:element name="NomElementSortie"> ... </xsl:element>	produit en sortie un élément du nom indiqué par l'attribut name. Des éléments xsl:attribute peuvent être imbriqués pour ajouter des attributs à l'élément produit en sortie.
<xsl:attribute name="NomAttribut"> ... </xsl:attribute>	produit en sortie un attribut qui sera inséré dans l'élément de sortie courant. Le contenu de l'élément xsl:attribute servira à définir la valeur que prendra l'attribut produit en sortie. Un contenu typique de l'élément xsl:attribute est <xsl:value-of />
Eléments de résultat litéraux: <NomElement NomAttribut="{UneExpression}"> ... </NomElement>	produit en sortie un élément du nom indiqué avec un attribut dont la valeur sera le résultat de l'expression fournie. Le contenu de l'élément d'entrée servira à définir le contenu de l'élément de sortie. Cette notation correspond à un raccourci d'écriture. Elle est équivalente à: <xsl:element name="NomElement"> <xsl:attribute name="NomAttribut"> <xsl:value-of select="UneExpression" /> </xsl:attribute> ... </xsl:element> Dans cet exemple, UneExpression peut être par exemple le nom d'un sous-élément de l'élément courant ou le signe @ suivi du nom d'un attribut de l'élément courant.
<xsl:sort select="Critère" order=...>	généralement imbriqué dans un xsl:apply-templates ou un xsl:for-each, trie les éléments concernés avant de les traiter, plutôt que de les traiter dans l'ordre d'apparition dans le document XML. L'attribut order doit valoir "ascending" ou "descending"

4. XSL-FO: LE FORMATAGE

XSL-FO (XML Stylesheet Language Formatting Objects) a pour objectif de définir un langage pour formater les données.

Il s'agit d'une application XML permettant de décrire la mise en page des données en sortie de traitement. Le formatage permet de décrire une mise en page en vue d'une génération vers : Navigateur, PDF, RTF, PostScript,....

Pour l'instant, il existe des outils qui permettent de générer un fichier au format PDF ou RTF, à partir du document XML : pour le PDF, l'application FOP de James Tauber disponible sur le site : http://xml.apache.org/fop/

4.1 XSL-FO par l’exemple

Voici un exemple de fichier XSL-FO et la visualisation du fichier PDF résultat, produit par FOP

1. LES FEUILLES DE STYLES: XSL ET CSS