TER 220 REALISATION D'UN EDITEUR XMLleclere/enseignements/TER/2007/Rapport/19.pdf ·...

CRESSON RégisMERCADIER HyacinthePERONNET AurélienSTEFAS Mickaël

MASTER INFORMATIQUE 1ere ANNEEUNIVERSITE MONTPELLIER 2

TER 220 REALISATION D'UN EDITEUR XML

Encadrant : Michel Meynard

1Rapport TER 2ème semestre

RemerciementsNous remercions l'Université Montepellier 2 de nous avoir donné les moyens matériels, et

intellectuels pour la bonne réalisation de notre projet, pour son enseignement dispensé et pour la

prise d'initiave de la création des Travails d'Etude et de Recherche.

Nous remercions le chef des projets de TER M. Leclere ainsi que notre encadrant M.Meynard pour

leur soutient, leur suivi et leur aide précieuse.

Nous remercions nos professeurs de nous avoir apporté les connaissances nécessaires à la

réalisation de notre projet et particulièrement Mme Mountaz et M. Pompidor pour leurs précieux

conseils en matiere d'interface graphique et en validation XML.

Nous remercions les membres du forum « http://www.developpez.com/ » ainsi que tous les

programmeurs mettant en ligne leurs connaissances dans un esprit de partage et de collaboration.


Table des matièresRemerciements..................................................................................................................................... 3Introduction : ....................................................................................................................................... 5I) Interface Graphique :........................................................................................................................ 7

1) Fenetre de hiérarchie des fichiers et des projets :.......................................................................7 2) Console de débuggage :.............................................................................................................8 3) fenêtre d'édition :....................................................................................................................... 8 4) fenêtres auxiliaires :...................................................................................................................9

II) Les problèmatiques ......................................................................................................................11 1) L'indentation automatique :...................................................................................................... 11 2) La coloration syntaxique : ....................................................................................................... 12 3)Le parseur SAX :....................................................................................................................... 12 4)Création d'un arbre dom interactif : ..........................................................................................13 5) Création d'un fichier DTD :......................................................................................................15

Conclusion et perspectives:................................................................................................................ 17 1)Perspectives:.............................................................................................................................. 17 2)Conclusion:................................................................................................................................17

Annexes.............................................................................................................................................. 18Annexe A : Etude de l'éxistant.......................................................................................................18Annexe B : Cahier des charges...................................................................................................... 22Annexe C : Manuel utilisateur....................................................................................................... 24Annexe D : Création d'arbres DOM ............................................................................................. 26Annexe E: Parseur ........................................................................................................................ 32Annexe F : Création de DTD.........................................................................................................33


Introduction : Le sujet de notre projet consiste en la réalisation d'un éditeur XML "user-friendly",

permettant à des novices ou des débutants de fabriquer facilement un document XML et visualiser

celui-ci dans un navigateur.

Notre interêt s'est porté sur ce projet car le XML est un format de données très en vogue

en ce moment et permet d'échanger des données très facilement. Il nous est apparu que c'était le

sujet le plus à même de nous permettre de réaliser un travail utile à la communauté des

informaticiens et aussi des novices.

De plus, ceci rassemblait quelques unes des matières de ce semestre et du précédent

(développement d'IHM, et bien evidemment galaxie XML) et nous permettait d'effectuer un projet

nécessitant la synthèse de beaucoup de nos connaissances acquises lors de notre parcours. Ceci

constituait donc un test idéal pour nous, futurs informaticiens professionnels, pour déterminer notre

capacité à programmer un logiciel d'une envergure supérieure à ce que nous avions fait jusqu'à

présent.

Nous avons essayé d'exploiter au maximum la programmation objet grâce à Java, en

adoptant une méthode de travail assez indépendante, en nous répartissant les tâches et en les

greffant au fur et à mesure à ce qui n'était, au début, qu'un squelette de programme. Ceci nous

permettait de pouvoir travailler séparément, entre deux réunions, sans pour autant avoir des soucis

de compatibilité entre nos codes, nous avons donc testé nos éléments de manière séparée et les

avons à chaque fois intégré le plus vite possible pour éviter toute surcharge de travail à la fin liée à

l'intégration de code.

Nous nous sommes basé sur le langage de programmation Java, car c'est un langage

robuste et portable sur tout systeme d'exploitation, ce qui nous permettait de travailler sous

n'importe quel système d'exploitation. Par ailleurs, notre cours d'IHM étant enseigné en langage

Java, il nous a paru naturel d'utiliser l'enseignement de notre professeur pour la réalisation de ce

TER. Enfin, la gestion des exceptions en Java est très utile à un outil permettant de valider du XML

dans la mesure où celà permet de récupérer des erreurs générées par une fonction (comme le

parseur) et de les afficher très rapidement là où on le désire.

L'environnement de dévéloppement utilisé est Eclipse car c'est un éditeur de code très

pratique et véritablement dans l'esprit du logiciel que nous voulions créer, à savoir simple à utiliser

et guidant l'utilisateur sur simple demande (auto-complétion,automatisation de certaines tâches

rébarbatives etc...). De plus il est gratuit et donc nous avons pu l'obtenir où que nous ayons travaillé.


Tout au long de ce rapport nous allons vous présenter d'une par la réalisation de

l'interface graphique en vous expliquant les efforts effectués afin de le rendre le plus intuitif,

convivial, et sobre possible. Et d'autre par la présentation de tous les outils implémentés dans notre

logiciel avec les problèmes que nous avons rencontré et les solutions adaptées.


I) Interface Graphique :La réalisation d'un interface graphique, intuitif , sobre et convivial, à été un de nos

principal défis. En effet, notre logiciel étant axé principalement pour des utilisateurs non confirmés,

il était indispensable que ceux-ci retrouvent un environement de travail familier qui leurs permette

une prise en main rapide du programme. L'implémentation de composants simples comme les

menus et la toolbar paraissait donc évidente. L'aspect visuel du logiciel devait permettre à

l'utilisateur de visualiser les différents écrans sans pour autant le « perdre » dans un nombre trop

important de fenetres. Notre interface se divise donc en quatres parties principales : Un fenêtre

globale (le corps du logiciel) et trois fenêtres filles permettant respectivement de visualiser la

hierarchie des fichiers et des projets en cours, la console de débuggage, et le fichier

XML/XSL/DTD en cours, associé à son arbre DOM.

1) Fenetre de hiérarchie des fichiers et des projets :

Cette fenêtre, visualisable à tout moment dans la partie

gauche de la fenêtre principale, permet à l'utilisateur de

visualiser les differents projets en cours avec leurs fichiers

XML/XSL/DTD associés. Par un simple clic sur le nom d'un

fichier son contenu devient visualisable et éditable dans la

fenêtre d'édition. L'apparition d'un « menu popup », grâce à un

clic droit de l'utilisateur, lui permet de réaliser les diférentes

actions de gestion de ces fichiers (création et importation de

fichier et de projet) de manière simple et intuitive.


2) Console de débuggage :

Cette fenêtre permet à l'utilisateur d'être tenu au courant en temps réel des différentes

alertes émises par le logiciel. Cela peut correspondre à des erreurs de validation des fichiers

XML/XSL, de création de l'arbre DOM, à des messages indiquant que la sauvegarde d'un fichier ou

d'un projet a été réalisée avec succès etc... Un bouton permetant d'éffacer la console à été ajoutée,

afin que l'utilisateur puisse « nettoyer » la fenêtre quand bon lui semble.

3) fenêtre d'édition :

Cette fenêtre est divisée en deux parties implémentées dans un écran splitté contenant le


fichier en lecture et l'arbre DOM correspondant. Cela permet donc à l'utilisateur de visualiser le

fichier et l'arbre en même temps. L'écran splitté peut, de plus, être redimensionnée afin de permettre

un affichage personalisé et correspondant aux besoins de l'utilisateur à un instant T. Un clic dans

l'arbre DOM repositionne automatiquement le curseur sur la balise (ou le contenu) correspondant,

dans la partie édition de l'écran splitté. Le systeme d'onglets (non implémenté dans la version en

cours et donc non visible sur les captures d'écran) contenant, pour chaque onglet un écran splitté,

permet à l'utilisateur de travailler sur plusieurs fichiers en même temps et de passer d'un document à

l'autre de manière rapide et intuitive. La coloration syntaxique des documents permet une meilleure

lisibilité des fichiers et rend l'interface plus agréable.

4) fenêtres auxiliaires :

Cette fenêtre permet à l'utilisateur de créer un

nouveau projet. Il lui sufit d'indiquer le nom du projet et

le nom du fichier XML. Un dossier portant le nom de ce

projet sera alors créé dans le dossier de sauvegarde du

logiciel (définie par l'utilisateur au lancement du logiciel).

Il est aussi possible de générer un fichier XSL

correspondant au fichier XML et portant le même nom.

Lors de la création des fichiers, les en-têtes XML

permettant de définir la méthode d'encodage et de créer le

lien entre le fichier XML et XSL sont automatiquement

ajoutés.


Cette fenêtre permet à l'utilisateur de créer un

nouveau fichier qui sera ajouté au projet séléctionné dans

la fenêtre de hiérarchie des fichiers et des projets. Comme

précédemment, si l'utilisateur décide de créer un fichier

XML, il peut choisir de créer le fichier XSL

correspondant


II) Les problèmatiques

1) L'indentation automatique :

Afin de faciliter l'utilisation du logiciel, nous avons décidé d'implémenter une fonction

d'indentation automatique du code. Ainsi lorsque l'utilisateur ferme une balise ouvrante XML, une

ligne est automatiquement sauté, une tabulation de plus que le nombre de tabulations présentes

avant la balise est ajouté et la balise fermante est automatiquement insérée à la ligne du dessous,

dans le même alignement que la balise ouvrante. Cette fonction de « guidage » permet aux

programmeurs XML occasionnels de créer du code lisible et plus aéré dans un langage où

l'imbrication des balises peut vite devenir chaotique et incompréhensible.

Avant fermeture de la balise : Après fermeture de la balise :

L'algorithme d'indentation est très simple et vous est détaillé ci-dessous:

Algorithme de calcul du nombre de tabulations{

● NombreDeTabulation = 0

● Le texte entre le debut du document et la position du curseur est enregistré

dans une chaine.

● La chaine est découpée en sous chaines dont le critère de découpage est la

découverte du caractère « < ».

● Pour chaque sous chaine disponible{

Si (le premier caractère de la sous chaine est un « / »){

//on se trouve sur une balise fermante

NombreDeTabulation = NombreDeTabulation - 1

}Sinon{

//on se trouve sur une balise ouvrante

NombreDeTabulation = NombreDeTabulation + 1

}

}


Ce nombre de tabulations est ensuite converti en une chaine de tabulations puis est

inseré à l'endroit désiré.

2) La coloration syntaxique :

Nous avons implémenté une fonction de coloration syntaxique automatique. Cela

permet à l'utilisateur d'avoir une meilleure lisibilité de son document. De par sa complexité, nous

avons eu beaucoup de mal à réaliser cette fonction. Son déroulement n'est pas optimal et nous

travaillons encore sur ce problème à l'heure actuelle. La fonction que nous avons réalisé permet de

colorer une partie du document comprise entre deux paramètres : un entier indiquant l'emplacement

du début du texte à colorer et un autre entier indiquant son emplacement de fin. De cette manière, il

est alors possible de ne colorer qu'une portion précise du document.

Malheureusement, nous avons rencontré des problèmes avec le gestionnaire de

coloration de java et un énorme bug nous empèche d'utiliser cette fonction de manière optimale. En

effet lorsque l'utilisateur ferme une balise XML, la fonction de coloration est lancé avec

l'emplacement de début et de fin de la balise. La balise est alors correctement colorée, mais une

partie aléatoire du texte s'en suivant est aussi colorée avec la dernière couleur utilisée par la

fonction. Nous pensons que cette erreur peut venir du fait que java interprète parfois le caractère

tabulation ( \t ) comme un unique caractère et parfois comme une suite de 6 espaces. La résolution

de ce problème est en cours et nous espérons pouvoir le régler a temps.

La solution utilisée pour le moment est la coloration de la balise et de tout le texte se

trouvant en dessous. Il paraît évident que pour l'insertion d'une balise au début d'un document de

plusieurs centaines de lignes, cette méthode n'est pas du tout performante. La coloration syntaxique

étant un objectif non présent dans le cahier des charges et que nous avons décidé d'aborder au cours

du developpement du logiciel, nous ne dénigrons pas son importance, mais nous considérons qu'une

l'implémentation non optimal ne devrait pas nous pénaliser.

3)Le parseur SAX :

SAX est une API java libre dédiée au XML. C'est maintenant un standard très utilisé.

Cette API est essentiellement basée sur des évènements. Un parser SAX ne construit pas d'arbre du


document en mémoire mais appelle les méthodes d'un handler lorsqu'il rencontre des évènements

particuliers (comme l'ouverture ou la fermeture d'un élément). On peut comparer la programmation

d'un tel parser à du développement d'interfaces graphiques où l'on gère des évènements générés par

l'utilisateur.

Voici l'architecture de l'API SAX :

Nous avons choisi SAX pour de simples raisons : le handler est une interface et il est

donc très facile de créer un parseur personalisé adapté à nos besoins en créant une classe qui

implémente l'interface ContentHandler. En outre, le handler par défaut suffit amplement à vérifier

la validité d'un document XML car il est facilement paramètrable. De plus, on peut aussi utiliser

SAX pour intervenir durant le parsing (comme, nous le verrons plus tard, pour la création de l'arbre

DOM).

Vérification du Document XML : L'instanciation du DefaultHandler (gestionnaire de

parsing par défaut de SAX) pour le parseur SAX permet de vérifier si le document est bien formé

avant de faire appel au parseur qui construit le DOM. La fonction de parsing, outre l'appel à la

fonction parse du parseur SAX, aura pour but de stocker les éventuelles erreurs dans une chaine de

caractère.

4)Création d'un arbre dom interactif :

Il existe une classe DOM en java mais elle n'était pas satisfaisante pour ce que nous

voulions réaliser, car elle ne rend que le DOM fini, et il est impossible d'intervenir durant le

parsing.

En effet, il était nécessaire de récupérer le numéro de ligne d'un élément afin de pouvoir

l'ajouter au noeud qui le représente, ceci afin que, lors d'un clic dans l'arbre DOM, le curseur se

déplace automatiquent à la ligne correspondante, facilitant ainsi la navigation dans le XML.


Pour la réalisation de l'arbre DOM , nous avons réalisé une classe qui construit un arbre

au fur et à mesure du parsing du document, tout en gardant la trace de ce qui a déjà été fait et ceci

afin de récupérer les lignes correspondantes à chaque élément du DOM dans le document.

Pour cela, nous avons utilisé un parseur SAX personnalisé et implémenté l'interface

ContentHandler qui est un gestionnaire de parsing, où l'on définit les tâches à effectuer par le

parseur à chaque balise ouvrante rencontrée, chaque element texte et chaque balise fermante.

L'alogrithme de construction d'arbre est très simple :

Algorithme ConstruireArbreEtParser{

arbre resultat ;

pointeursurnoeud noeudcourant = racine(resultat) ;

si(balise ouvrante rencontrée){

chaine valeurbalise = recuperer(nombaliseouvrante) ;

pour chaque attribut faire{

chaine attribut = (NomAttribut,'=',ValeurAttribut);

concatener(attribut,valeurbalise);

}

NouveauNoeud = CreerNoeud(valeurbalise,numerolignebalise) ;

AjouterNoeudFils(noeudcourant,NouveauNoeud) ;

noeudcourant = NouveauNoeud ;

}

si(chaine à l'interieur d'une balise rencontrée)

{

chaine valeurtexte = recuperer(valeur de la chaine) ;

NouveauNoeud = CreerNoeud(valeurtexte,numerolignetexte);

AjouterNoeudFils(noeudcourant,NouveauNoeud);

}

si(balise fermante rencontrée)

{

noeudcourant = pere(noeudcourant) ;

}

}


L'arbre est donc construit itérativement, avec une complexité équivalente à un parcours

en profondeur.

Ensuite lors de l'utilisation de l'arbre et grâce à la gestion des evenements java, le

numéro de ligne d'un élément est récupéré lors du clic sur celui-ci et la position du curseur est

changée en conséquence.

En cas d'erreur dans le parsing DOM et dans la construction de l'arbre, les exceptions

lancées par la fonction de construction sont automatiquement redirigées vers la console prévue à cet

effet dans l'interface, permettant à l'utilisateur de juger de son erreur et si possible la réparer (les

erreurs SAX sont en anglais mais à terme, nous espérons pouvoir les traduire).

Note : le code source java implémentant cet algorithme est situé dans la classe

DOMContentHandler jointe en annexe.

5) Création d'un fichier DTD :

L'éditeur est capable de générer un fichier de DTD associé à un document XML. La

DTD générée est simple et générale, nous sommes partis du principe qu'il est difficile de savoir

exactement quel type de modèles de fichiers l'utilisateur veut créer à partir d'un seul, il nous a donc

semblé plus pertinant de créer des DTDs très générales plutôt que des DTDs très spécifiques.

Pour faciliter la création de la DTD, on a conçu une structure de données nommée

balise qui contiendra une balise ainsi que ses fils dans l'arbre DOM.

En ce qui concerne l'ajout de nouvelle ligne dans la DTD, il faut vérifier que l'élément

n'a pas déjà été inséré, ce qui a nécessité l'utilisation d'un vecteur.

De même, en ce qui concerne l'insertion d'éléments contenus dans une balise, il faut

vérifier que l'élément est différent de l'élément précédant, par contre l'élément peut déjà être

présent.

La création de la dtd se fait de la façon suivante :


on parcours le fichier XML pour récupérer l'arbre DOM correspondant au fichier XML

pour chaque noeud de l'arbre {

on ajoute le noeud dans un vecteur de balises

pour chaque fils du noeud :

on ajoute le fils du noeud dans le vecteur

on applique la fonction récursivement sur le fils.

}

Une fois que l'arbre est entièrement parcouru, on parcoure le vecteur de balises afin de

remplir le nouveau fichier de DTD.

Voici un exemple de code XML et de la DTD générée par le programme :


Conclusion et perspectives:

1)Perspectives:

De nombreuses améliorations peuvent être implémentées dans notre projet, nous

pensons notamment à une refonte du système de coloration syntaxique de manière à le rendre plus

rapide, à la réalisation d'un assistant de création de DTD plus poussé, ainsi qu'à une optimisation du

positionnement du curseur dans le document lors d'un clic dans l'arbre DOM. De plus nous

pourrions ajouter d'autres fonctionnalités telles qu'un plus grand nombre de grammaires

d'indentation et differents types de colorations, la création de lien entre les erreurs de validation du

document XML dans la console et le document, avec, éventuellement, la coloration des erreurs dans

celui-ci.

2)Conclusion:

Pour finir, nous pouvons dire que ce projet nous a permis de tester nos capacités face à

une tâche de plus grande envergure, et nous espérons à ce titre que notre logiciel pourra être

amélioré et utilisé par le plus grand nombre de personnes possibles. Nous regrettons de ne pas avoir

pu implémenter les fonctionnalités décrites dans le paragraphe ci-dessus et pour celà, nous désirons

mettre les sources du logiciel à disposition de la communauté des developpeurs, pour respecter

l'esprit de développement de logiciel libre en vigueur à la faculté. Nous allons d'ailleurs mettre le

programme en ligne sur Internet sous forme d'applet Java, afin de faire un éditeur XML utilisable en

ligne.


Annexes

Annexe A : Etude de l'éxistant

Ce document correspond à l'étude de l'éxistant que nous avons réalisé au début de notre

projet.

HTML-Kit :– Developpeur : Chami software

– Prix : gratuit

– Capture d'écran :

– Présentation : Comme son nom l'indique, HTML-Kit est une solution complète pour fabriquer

du HTML et par là même du XML.


– Fonctionnalités:

– Parseur : Il intégre son propre parseur XML et l'on peut donc visualiser le document tout en

restant dans le logiciel, donc sans passer par le parseur d'un navigateur internet par

exemple.Toutefois, l'interprétation du document XML et de sa feuille de style XSL pouvant

varier selon les parseurs, on peut effectuer l'affichage dans différents navigateurs grâce à un

menu associé. On peut aussi appeler le validateur du W3C grâce au menu Online, pour

valider son document sur le site et vérifier sa conformité par rapport aux standards.

– Outils : différents outils de traitement du texte classiques, et certains plus spécifiques au

XML et au HTML, comme la conversion autmatique des noms de balises et des attributs en

minuscules (pour respecter les consignes du XHTML 1.0), et l'insertion automatique des

balises standard (comme les balises meta, déclaration de version, balise dtd, etc...).

– Interface :

– L'interface se présente de manière classique : barre d'outils, pour les actions de base

(nouveau, sauvegarder...) et plusieurs onglets en dessous, ouvrant chacuns sur une autre bare

d'outils dédiée à un rôle spécifique (barre d'outils pour les tableaux, barre pour les

fonctionnalités online etc...). En ce qui concerne le document XML en lui même, le logiciel

utilise une navigation par onglets, permettant de jongler entre l'affichage du code, et de son

résultat par l'interpréteur. Il est même possible de partager la fenetre en plusieurs parties,

afin de pouvoir éditer et visualiser plusieurs documents en même temps.

– Conclusion : HTML-Kit est un bon exemple d'éditeur XML classique dans la mesure où il

est intégré à une solution de création de HTML. Certaines fonctionnalités sont curieusement

absentes, comme la fonction de visualisation de l'arbre DOM, qui est pourtant primordiale

pour un document XML. C'est l'exemple classique des solutions dites « tout-en-un »,


EDITEUR TEXTE-XSLTPROC-MOZILLA:– Developpeur : à compléter

–

– Prix: gratuit

–

– Capture d'écran : à ajouter

– Présentation: L'usage du triplet, éditeur texte + XSLTPROC + Mozilla est une des solution les

plus simple pour écrire un document XML sous linux car elle est automatiquement disponible

sous n'importe quelle distribution de Linux (au moins pour les plus courantes).

– Fonctionnalités :

– En ce qui concerne l'éditeur de texte, elles sont variables, en général, la plupart des éditeurs

de texte sous linux (comme KATE ou KWRITE) permettent la coloration syntaxique ainsi

que la reconnaissance automatique du langage, et intègrent en outre toutes les fonctions de

traitement de texte classiques.

– Mozilla (ou firefox, ou même tout autre naviateur doté d'un interpréteur XML) a pour rôle

de donner un aperçu du document final après interprétation par la feuille de style XSL.

– XSLTPROC sert à combler le manque d'information donné par les interpréteurs XML des

navigateurs en cas d'erreurs dans le document. Il est très simple d'utilisation (une simple

ligne de commande du type : xsltproc docxml.xsl docxml.xml docxml.dtd suffit à lancer

l'analyse) et renvoie une liste d'erreurs détaillée le cas échéant.

– Interface: L'interface de cette solution est celle adoptée par les différents logiciels qui la

composent, elle est donc très variable suivant l'éditeur de texte utilisée. XSLTPROC se lance en

ligne de commane et dépend donc du type de terminal installé. Enfin, Mozilla adopte une

interface très simple d'accès dans la mesure où l'on peut ouvrir plusieurs documents en même

temps dans différents onglets.

– Conclusion : Même si cette solution composée de trois logiciels peut paraître archaïque, elle a le

mérite d'être directement accessible et personnalisable car il existe de nombreux éditeurs de

textes et navigateurs différents, permettant à chacun de constituer sa propre solution adaptée à


sa manière de travailler. Enfin, XSLTPROC est un outil très efficace utilisé aussi bien par des

amateurs que des professionnels (selon l'avis de différents forums, dont celui de

Developpez.com, référence en matière developpement) et s'acquitte très bien de sa tâche malgré

son utilisation basique en ligne de commande.


Annexe B : Cahier des chargesCe document correspond au cahier des charges que nous avons rendu avant le

commencement de la phase d'analyse.

I) Présentation du sujet et objectifs :

a) Présentation:Le sujet que nous nous proposons de réaliser est un logiciel d'édition de fichiers XML

(eXtensible Markup Language). Cette réalisation entre dans le cadre de notre TER de deuxième semestre de première année de master informatique. Nous serons tout au long de ce travail, guidé par notre encadrant de TER, M. Michel Meynard. Il s'agit d'un projet de plus grande envergure que ce que nous avons eu à faire tout au long de notre cursus scolaire.

b) Objectifs :Lors de notre rencontre avec M. Meynard, nous avons défini ensemble plusieurs

objectifs :

– Edition et validation de fichiers XML (en utilisant un validateur externe), et de feuilles de styles XSL associées:

Dans le cadre principal de l'interface, l'utilisateur pourra saisir son code XML, puis le valider afin de vérifier si celui-ci contient des erreurs, et le cas échéant, les surligner dans une couleur particulière afin de les rendre facilement repérables.

– Création et affichage de l'arbre DOM (Document Object Model) :

L'arbre DOM associé au fichier XML (hiérarchie des balises, etc...) devra pouvoir être visualisable en temps réel et suivre la position du curseur dans la fenêtre principale.

– Réalisation et implémentation d'une grammaire DTD (Document Type Definition) générale à partir du document XML (reverse-engineering):

A partir d'un code XML, le programme devra pouvoir générer une DTD minimale, qui pourra ensuite être complétée par l'utilisateur, afin de créer un modèle pour un type de document donné. Ceci afin d'automatiser la création de DTD, qui est difficile et peu ergonomique pour le profane.

– Réalisations de plusieurs gammaires d'indentation pour le code:

Ceci permettra à l'utilisateur de choisir le type d'indentation désiré pour son code et ainsi l'organiser de manière plus conviviale. Différents styles : à la manière de C, C++, Java, html etc...

– Visualisation en temps réel des modifications effectuées sur le code dans un navigateur:


A l'aide d'un interpréteur XML externe, le code saisi par l'utilisateur entrainera la modification en temps réel de la fenêtre navigateur et permettra un aperçu immédiat des changements effectués.

– Réalisation d'une interface la plus conviviale, intuitive et ergonomique possible.

–

I) Planning de travail:


Semaine du :5/02 au 11/02 Etude 12/02 au 18/02 du marché19/02 au 25/02 existant26/02 au 4/03 maquettes d'interface5/03 au 11/03 Implémentation Algorithmes

12/03 au 18/03de de l'arbre DOM

L'interface Code source19/03 au 25/03 général26/02 au 1/03 Mise en commun2/03 au 8/03 Génération Réalisation 9/03 au 15/03 des des grammaires16/03 au 22/03 DTD d'indentation23/03 au 29/03 Visualisation dans le navigateur30/03 au 6/04 Semaine de sécurité7/04 au 13/04

Légende : Tâche réalisée par toutes les personnesTâche réalisée par groupe de 2 personnes

Annexe C : Manuel utilisateur

Le logiciel étant conçu de la manière la plus simple possible, ce manuel est très succint car le programme ne nécessite aucune sorte d'apprentissage particulière, mise à part bien sûr la connaissance du langage XML :

I) Gestion des projets :

Première chose à faire : choisir le répertoire de sauvegarde des projets.

Puis il suffit de choisir l'option créer un nouveau projet dans le menu fichier.

On peut choisir de créer automatiquement une feuille de style associée

au premier document du projet en cochant la case prévue à cet effet.

On peut aussi choisir d'ouvrir un projet éxistant à l'aide de l'option ouvrir un

projet

Il est de plus possible de créer ou d'importer un nouveau fichier dans un

projet existant par l'intermédiare, respectivement des options créer un

nouveau fichier et importer un fichier

II) Edition du XML :Ensuite l'édition du XML se fait le plus simplement du monde : en tapant

dans la zone de code prévue à cet effet. On peut tout moment naviguer dans

le document grâce à l'arbre DOM interactif dans le volet de gauche.

III)Création de DTD

Une fois que le fichier XML est terminé, il est possible de générer une

DTD, pour cela cliquer sur le bouton créer une DTD dans le menu outils.

Le fichier est créé dans le dossier contenant le projet.

IV) Visualisation du document :Enfin, une fois l'édition du document XML et de la feuille de style XSL


terminée, il suffit de cliquer sur l'option visualiser le document dans le menu

édition.


Annexe D : Création d'arbres DOM

import javax.swing.tree.DefaultMutableTreeNode;

public class DOMMutableNode extends DefaultMutableTreeNode {

private int Position ;private int PositionLigne;

public DOMMutableNode(){

super();Position = 0 ;PositionLigne = 0 ;

}

public DOMMutableNode(String str, int pos, int posl){

super(str);Position = pos ;PositionLigne = posl ;

}

public int getpos(){

return this.Position ;}public int getposl(){

return this.PositionLigne;}

public DOMMutableNode Parent() {

return (DOMMutableNode)this.parent;}

}

import javax.swing.JTree;import javax.swing.tree.DefaultTreeModel;

import org.xml.sax.*;import org.xml.sax.helpers.LocatorImpl;

// ContentHandler pour le parseur qui crée une représentation du DOM dans un JTreepublic class DOMContentHandler implements ContentHandler {


// JDOM est un JTree qui sera complété avec les noeuds DOM au fur et à mesure du parsing

public JTree JDOM ;// Noeud Courant est le noeud parent auquel on va ajouter les

éléments DOM rencontrés// Il varie au cours du parsingDOMMutableNode NoeudCourant ;

/** * Constructeur par defaut. */ public DOMContentHandler() { super(); this. // On definit le locator par defaut. locator = new LocatorImpl(); // L'arbre Dom n'est jamais vide, il a une racine qui pointe vers le début du document DOMMutableNode Racine = new DOMMutableNode("Racine du DOM",0,0); JDOM = new JTree(new DefaultTreeModel(Racine)); // Le noeud courant est la racine (logique) NoeudCourant = Racine ; }

/** * Definition du locator qui permet a tout moment pendant l'analyse, de localiser * le traitement dans le flux. Le locator par defaut indique, par exemple, le numero * de ligne et le numero de caractere sur la ligne. */ public void setDocumentLocator(Locator value) { locator = value; }

/** * Evenement envoye au demarrage du parse du flux xml. * @throws SAXException en cas de probleme quelquonque ne permettant pas de * se lancer dans l'analyse du document. * @see org.xml.sax.ContentHandler#startDocument() */ public void startDocument() throws SAXException { System.out.println("Debut de l'analyse du document"); }

/** * Evenement envoye a la fin de l'analyse du flux xml. * @throws SAXException en cas de probleme quelquonque ne permettant pas de * considerer l'analyse du document comme etant complete. * @see org.xml.sax.ContentHandler#endDocument() */ public void endDocument() throws SAXException { System.out.println("Fin de l'analyse du document" ); }


/** * Debut de traitement dans un espace de nommage. * @param prefixe utilise pour cet espace de nommage dans cette partie de l'arborescence. * @param URI de l'espace de nommage. * @see org.xml.sax.ContentHandler#startPrefixMapping(java.lang.String, java.lang.String) */ public void startPrefixMapping(String prefix, String URI) throws SAXException { System.out.println("Traitement de l'espace de nommage : " + URI + ", prefixe choisi : " + prefix); }

/** * Fin de traitement de l'espace de nommage. * @param prefixe le prefixe choisi a l'ouverture du traitement de l'espace nommage. * @see org.xml.sax.ContentHandler#endPrefixMapping(java.lang.String) */ public void endPrefixMapping(String prefix) throws SAXException { System.out.println("Fin de traitement de l'espace de nommage : " + prefix); }

/** * Evenement recu a chaque fois que l'analyseur rencontre une balise xml ouvrante. * @param nameSpaceURI l'url de l'espace de nommage. * @param localName le nom local de la balise. * @param rawName nom de la balise en version 1.0 <code>nameSpaceURI + ":" + localName</code> * @throws SAXException si la balise ne correspond pas a ce qui est attendu, * comme par exemple non respect d'une dtd. * @see org.xml.sax.ContentHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes) */ public void startElement(String nameSpaceURI, String localName, String rawName, Attributes attributs) throws SAXException { // On récupère le nom de la balise ouvrante String NodeContenu = localName ; // Et ses attributs for (int index = 0; index < attributs.getLength(); index++) { // on parcourt la liste des attributs if(index == 0 && attributs.getLength() > 0) { NodeContenu += " Attribut(s)"; } NodeContenu += " ::" + attributs.getLocalName(index) + " = " + attributs.getValue(index); } // On crée ensuite un nouveau noeud contenant le nom de l'élément et les attributs le cas échéant DOMMutableNode Dmd = new DOMMutableNode(NodeContenu,locator.getLineNumber(),locator.getColumnNumber()); // On l'ajoute à son père


NoeudCourant.add(Dmd); // Et on descend d'un niveau dans l'arbre NoeudCourant = Dmd; }

/** * Evenement recu a chaque fermeture de balise. * @see org.xml.sax.ContentHandler#endElement(java.lang.String, java.lang.String, java.lang.String) */ public void endElement(String nameSpaceURI, String localName, String rawName) throws SAXException { // Si on rencontre une balise fermante, on remonte d'un niveau dans l'arbre NoeudCourant = NoeudCourant.Parent() ;

}

/** * Evenement recu a chaque fois que l'analyseur rencontre des caracteres (entre * deux balises). * @param ch les caracteres proprement dits. * @param start le rang du premier caractere a traiter effectivement. * @param end le rang du dernier caractere a traiter effectivement * @see org.xml.sax.ContentHandler#characters(char[], int, int) */ public void characters(char[] ch, int start, int end) throws SAXException { // On fabrique une String avec le tableau de caractères String Result = new String(ch,start,end); // Filtrage des noeuds blancs grâce au trim if(Result.trim().length() != 0) { // le nouveau noeud est crée et ajouté à son père avec ses valeurs de ligne et de colonne DOMMutableNode Dmd = new DOMMutableNode("Valeur : " + Result,locator.getLineNumber(),locator.getColumnNumber()); NoeudCourant.add(Dmd); } }

/** * Recu chaque fois que des caracteres d'espacement peuvent etre ignores au sens de * XML. C'est a dire que cet evenement est envoye pour plusieurs espaces se succedant, * les tabulations, et les retours chariot se succedants ainsi que toute combinaison de ces * trois types d'occurrence. * @param ch les caracteres proprement dits. * @param start le rang du premier caractere a traiter effectivement. * @param end le rang du dernier caractere a traiter effectivement


* @see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int) */ public void ignorableWhitespace(char[] ch, int start, int end) throws SAXException { // rien de spécial à faire ici, si on rencontre des espaces inutiles, on ne fait rien }

/** * Rencontre une instruction de fonctionnement. * @param target la cible de l'instruction de fonctionnement. * @param data les valeurs associees a cette cible. En general, elle se presente sous la forme * d'une serie de paires nom/valeur. * @see org.xml.sax.ContentHandler#processingInstruction(java.lang.String, java.lang.String) */ public void processingInstruction(String target, String data) throws SAXException { // rien ici non plus, les instructions de fonctionnements ne servents pas pour le DOM }

/** * Recu a chaque fois qu'une balise est evitee dans le traitement a cause d'un * probleme non bloque par le parser. * @see org.xml.sax.ContentHandler#skippedEntity(java.lang.String) */ public void skippedEntity(String arg0) throws SAXException { // on ne fait rien, c'est le cas d'un problème qui n'a pas été bloqué par le parseur }

private Locator locator; //renvoie l'arbre DOM construit par le Handler public JTree getJDOM() { return this.JDOM; }

}

import java.io.File;import java.io.IOException;import java.util.logging.ConsoleHandler;

import javax.swing.JTree;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.ParserConfigurationException;


import javax.xml.parsers.SAXParserFactory;import javax.xml.transform.TransformerException;

import org.w3c.dom.Document;import org.xml.sax.SAXException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;import org.xml.sax.XMLReader;

public class DomParseur {

public static JTree ParserDOM(String uri) throws SAXException, IOException { XMLReader saxReader = XMLReaderFactory.createXMLReader(); DOMContentHandler DCH = new DOMContentHandler(); saxReader.setContentHandler(DCH); saxReader.parse(uri); JTree DOM = DCH.getJDOM(); return DOM ; }

public static JTree XMLToDom(String Path, FenetrPrincipale fp){

// conversion d'un document XML en document DOMtry{

// lecture du contenu d'un fichier XML dont le chemin est passee en parametre avec DOM

File xml = new File(Path);JTree DOM = ParserDOM(Path);

return DOM ;

}catch(SAXException se){

fp.Console.modifTexte(se.toString());return null ;

}catch(IOException ioe){System.out.println("Erreur d'entree-

sortie");System.out.println("lors de l'appel de

construteur.parse(xml)");return null ;

}}

}


Annexe E: Parseur

import java.io.*;import org.xml.sax.*;import org.xml.sax.helpers.DefaultHandler;import javax.xml.parsers.SAXParserFactory;import javax.xml.parsers.ParserConfigurationException;import javax.xml.parsers.SAXParser;public class Parseur extends DefaultHandler {

String fichier;public Parseur (String f)

throws IOException {super();fichier=f;

}

public String parse() throws IOException{ DefaultHandler handler = new Parseur(fichier); String s=""; SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setValidating(false); try { SAXParser saxParser = factory.newSAXParser(); saxParser.parse( new File(fichier), handler ); } catch (SAXParseException e) { // prise en charge des erreurs de parsing s=s+"\n** Parsing error" + ", line " + e.getLineNumber() + ", uri " + e.getSystemId(); s=s+"\n " + e.getMessage() ; System.out.println(s); if (e.getException() != null) e.getException().printStackTrace(); } catch (SAXException e) { // prise des erreurs SAX if (e.getException() != null) e.getException().printStackTrace(); } catch (ParserConfigurationException e) { // prise en charge des erreurs de // configuration (factory) e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } s=s+"\n parsing terminÃ©"; return (s); } public void error(SAXParseException e) throws SAXParseException { throw e; }}


Annexe F : Création de DTDimport org.w3c.dom.*; import java.io.*;import java.util.*;//Version 1.0 de la dtdpublic class MakeDTD {

Document doc;String nomFichier;

//constructeur public MakeDTD(Document doc, String nomF){

this.doc=doc;nomFichier=nomF;

}

public void create() throws IOException{PrintWriter writter=new PrintWriter(new BufferedWriter

(new FileWriter(nomFichier+".dtd"))); //initialisation de l'ecrivain

final NodeList ndl = doc.getChildNodes(); //on va parcourir l'arbre dom pour creer la dtd

VecteurBalises vs1=new VecteurBalises();int i = 1;

if(ndl.getLength()>1){

//on parcours la NodeListwhile(ndl.item(i) != null && i<ndl.getLength()){

Node nd = ndl.item(i);vs1=createBis(nd,vs1); //appel a la procedure

recursive qui va remplir le fichieri++;}

}

//on remplit ligne par le fichier DTDfor(int k=0;k<vs1.size();k++){

Balise b=(Balise)vs1.get(k);if(!b.getNom().equals("#text")){

writter.print("<!ELEMENT "+b.getNom()+" (");

writter.print(b.afficherEnfants());writter.println(")>");

}}writter.close(); //fermeture du fichier

}

public VecteurBalises createBis(Node nd,VecteurBalises vs1) throws IOException{


//Vector vs=new Vector();

int index;

Balise b=new Balise(nd.getNodeName());//si la balise n'est pas dans le vecteurif(!vs1.contains(b.getNom())){

vs1.add(b);}//si le noeud n'estr pas un noeud de type texteindex=vs1.indexOf(b.getNom());NodeList childs=nd.getChildNodes(); //on

recupere les fils//si il y a des filsif(childs.getLength() > 0){

//si le noeud n'est pas de type texteif(!b.getNom().equals("#text")){

int j=0; //j permettra de parcourir tous les noeuds

while(j < childs.getLength() && childs.item(j) != null)

{

//cas d'un noeud de type texte

if(childs.item(j).getNodeName().equals("#text") && childs.item(j).getNodeValue().trim().length() != 0 ){

((Balise)vs1.get(index)).ajouterEnfant("#PCDATA");}

//sinonelse

if(!childs.item(j).getNodeName().equals("#text")){

((Balise)vs1.get(index)).ajouterEnfant(childs.item(j).getNodeName()+'*');

vs1=createBis(childs.item(j), vs1); //on appelle recursivement la fonction

}j++;

}}

}

return vs1;}

}


TER 220 REALISATION D'UN EDITEUR XMLleclere/enseignements/TER/2007/Rapport/19.pdf ·...

Documents

Transcript of TER 220 REALISATION D'UN EDITEUR XMLleclere/enseignements/TER/2007/Rapport/19.pdf ·...