[dÉveloppement d'un plugin pour la ...nihil.is.free.fr/root/eclipse/charte de projet.docx ·...

[[DÉVELOPPEMENT D'UN PLUGIN POUR LA PLATEFORME ECLIPSE]]

Charte de ProjetFranck LagraveUgo PradèreRabot Sylvain

Projet commandité et tutorépar Mr. Thierry Nodenot

PROJET 14 : DEVELOPPEMENT D’UN PLUGIN POUR LA PLATEFORME ECLIPSE Charte de Projet

IUT DE BAYONNE – DÉPARTEMENT INFORMATIQUE 2

IUT DE BAYONNE – DÉPARTEMENT INFORMATIQUE Année 2006 - 2007


Remerciements

Tout d’abord nous tenons à remercier notre tuteur et commanditaire Monsieur Thierry Nodenot pour nous avoir accompagné tout au long de ce projet.

Nous remercions Madame Marion Latapy-Etcheverry pour l’écoute et le soutien qu’elle nous a apporté.

Nous aimerions également exprimer notre sincère reconnaissance à nos professeurs de communication :

- Monsieur Gilles Janin pour la coopération régulière et constructive qu'il nous offre pour traiter de nombreuses questions relatives au projet et à nos études.

- Madame Corine Ospital pour l’enseignement qu’elle nous a prodigué tant sur le plan des soutenances orales que sur le plan de la présentation de documents.

Nous adressons un remerciement à Monsieur Christophe Marquesuzaà.

Nous voulons également remercier tout les autres professeurs pour le savoir qu’ils nous ont inculqué au cours de notre cursus au sein de l’IUT.



Table des matières

Remerciements..........................................................................................................................21. Présentation générale du projet.......................................................................................5

1.1. Enjeux...........................................................................................................................51.2. Fonctionnalités.............................................................................................................51.3. Qualité de service attendue..........................................................................................61.4. Limites..........................................................................................................................6

2. Document de référence......................................................................................................72.1. Présentation d’Eclipse..............................................................................................7XML....................................................................................................................................8Schéma XML (XML Schema, XSD)..................................................................................9Diagramme de classes.......................................................................................................10Diagramme d’objets..........................................................................................................11XML Metadata Interchange (XMI)...................................................................................12

2.2. Relevés de décisions...................................................................................................123. Participation des services utilisateurs............................................................................13

3.1. Les commanditaires du projet....................................................................................133.2. Les utilisateurs du projet............................................................................................133.3. Les financeurs du projet.............................................................................................13

4. Champ du projet..............................................................................................................144.1. Cadre stratégique........................................................................................................144.2. Objectifs de gestion....................................................................................................144.3. Orientations d’organisation........................................................................................14

Avantages..........................................................................................................................14Inconvénients.....................................................................................................................15Contraintes.........................................................................................................................15

5. Plan d’action....................................................................................................................165.1. Démarche de développement.....................................................................................16

Familiarisation avec notre projet et les outils à utiliser.....................................................16Rédaction de la charte........................................................................................................16Programmation..................................................................................................................16Tests...................................................................................................................................16Documentation finale........................................................................................................16Préparation à la soutenance orale......................................................................................16

5.2. Calendrier prévisionnel..............................................................................................16IUT DE BAYONNE – DÉPARTEMENT INFORMATIQUE 4


5.3. Organisation du projet................................................................................................166. Bilan..................................................................................................................................177. Annexes.............................................................................................................................18

7.1. Sujet original du projet de synthèse...........................................................................187.2. Comptes rendus de réunions......................................................................................20

Réunion du 02/10/2006.....................................................................................................20Réunion du 08/11/2006.....................................................................................................20Réunion du 21/12/2006.....................................................................................................20Réunion du 18/01/2007.....................................................................................................20Réunion du 01/02/2007.....................................................................................................21Réunion du 15/02/2007.....................................................................................................21Réunion du 01/03/2007.....................................................................................................21

7.3. Documentation supplémentaire sur Eclipse, création d’un plug-in et d’une application.............................................................................................................................22

7.3.1. Présentation d’Eclipse.........................................................................................227.3.1.1. Historique........................................................................................................227.3.2. Les plug-ins Eclipse............................................................................................247.3.3. Les applications Eclipse......................................................................................317.4. Diagramme de Gantt du projet...............................................................................42



1. Présentation générale du projet

Ce projet entre dans le cadre de notre projet de synthèse de notre seconde année au département Informatique de l’Institut Universitaire de Bayonne.

Ce projet tourne autour de l’extensibilité de l’environnement de développement intégré Eclipse. Cette plateforme de programmation initialement développée par la société IBM et dont le projet a été rendu Open Source, a pour particularité d’avoir été totalement développée autour de la notion de plug-ins ou extensions en français. Cela signifie que toutes les fonctionnalités d’Eclipse proviennent de l’adjonction de plug-ins au logiciel. Par exemple le développement avec les langages tels que Java, PHP, Javascript, XML, HTML, XUL, SQL, etc… est possible sur Eclipse grâce à l’ajout de plug-ins.

Notre projet consiste à créer une application Eclipse dont le but sera de permettre à un utilisateur de représenter graphiquement un diagramme de classes ou d’objets UML 2.0 en se basant sur des informations contenues dans des fichiers XML liés avec des fichiers XSD (XML Schema).

Les membres de ce projet sont, par ordre alphabétique, Franck Lagrave, Ugo Pradere et Sylvain Rabot. Le commanditaire et tuteur de ce projet est Monsieur Thierry Nodenot, enseignant chercheur à l’Université de Pau et des Pays de l’Adour.

1.1.Enjeux

Notre commanditaire pourrait se servir de cette application dans ses recherches. Notre application devra lui permettre de récupérer des fichiers XML/XSD répertoriés dans une base de données à Pau ou disponibles sur son espace de travail, les vérifier, les modifier et les afficher.

1.2.Fonctionnalités

La production finale de notre projet prendra la forme d’une application Eclipse. Cette application écrite en Java aura pour but d’importer des fichiers XML accompagnés de leur XSD, de vérifier que le fichier XML est en accord avec son fichier XSD. Une fois les fichiers importés, l’utilisateur aura la possibilité de les éditer en agissant ainsi directement sur la source ou en utilisant un plug-in préexistant d’Eclipse : WST (Web Standard Tools).

Les fichiers devront également pouvoir être importés depuis une base de données de type Exist basé à Pau via un service web.



1.3.Qualité de service attendue

Du point de vue de l’interface, nous devons établir la position des vues dans notre application (gestion de projet, édition de fichiers XML/XSD, affichage des diagrammes, etc.). Voici de quelle manière est prévu l’agencement des vues dans notre application :

(1) Vue permettant la gestion de projets(2) Vue permettant l’édition de fichiers XML/XSD et l’affichage du diagramme de classes correspondant(3) Barre de menu d’Eclipse

1.4.Limites

Les limites qui nous sont imposées sont des limites techniques qui viennent des contraintes d’exportation en diagramme de classes ou d’objets UML 2.0 et d’utilisation de la base de données Exist, des fichiers XML et XSD. En effet, notre application sera dépendante du format et des informations présentes dans les fichiers XML et XSD qui nous seront fournis.

Une autre limite de notre projet serait le fait de ne pas trouver de plug-in d’exportation en diagramme d’objets UML 2.0 de fichiers XML. En effet, à l’heure actuelle nous utilisons le plug-in hyperModel qui convertit un fichier XSD en diagramme de classes mais nous n’avons pas de plug-in nous permettant de transcrire un fichier XML en diagramme d’objets.



2. Document de référence

Les différents produits que nous allons utiliser au cours de notre projet sont XML, XSD, XMI, Java, Eclipse et divers plug-ins applicables à Eclipse (comme hyperModel et WST)

2.1. Présentation d’Eclipse

Eclipse est un environnement de développement intégré qui a la particularité de fonctionner grâce à l’adjonction de composants supplémentaires appelés « plug-ins » qui permettent d’ajouter au logiciel des fonctionnalités complémentaires.

La particularité d’Eclipse réside également dans la possibilité de création d’applications autonomes (ex. : Azureus) qui intègreront eux-mêmes différents plug-ins. C’est sur cette notion d’applications que repose notre projet.

Aperçu d’une application Eclipse de base :

(1) Vue permettant la gestion de projet(2) Vue permettant l’édition de fichier (ici d’une classe Java)(3) Barre de menu d’Eclipse (4) Zone d’affichage des erreurs

Documentation Eclipse : Eclipse : http://www.eclipse.org/


http://www.eclipse.org/


Wikipedia : http://fr.wikipedia.org/Eclipse_(logiciel)/ Eclipse Plug-in Central : http://www.eclipseplugincentral.com/

XML

XML pour eXtensible Markup Language (« langage de balisage extensible ») est un langage informatique de balisage définit par le W3C, World Wide Web Consortium. C’est une amélioration du langage HTML. On se sert de ce langage pour le transfert de contenus et d’informations entre des systèmes d’informations.

Dans notre projet, le langage XML sera utilisé par les fichiers sources fournis par l’utilisateur à l’application Eclipse.

Documentation XML : W3C : http://www.w3.org/XML/ Wikipedia : http://fr.wikipedia.org/wiki/Extensible_Markup_Langage XML.com : http://www.xml.com/ W3Schools.com : http://www.w3schools.com/xml/ Commentcamarche.net : http://www.commentcamarche.net/xml/xmlintro.php3/


<personne><codepers>2110</codepers>

<nompers><nom>Hubert</nom><prenom>Roger</prenom>

</nompers><adressepers>

<numero>20</numero><rue>Victor Hugo</rue><ville>Bayonne</ville><pays>France</pays>

</adressepers><coordpers>

<email>[email protected]</email><tel>05.58.60.39.19</tel>

</coordpers></personne>

http://www.commentcamarche.net/xml/xmlintro.php3/

http://www.w3schools.com/xml/

http://www.xml.com/

http://fr.wikipedia.org/wiki/Extensible_Markup_Langage

http://www.w3.org/XML/

http://www.eclipseplugincentral.com/

http://fr.wikipedia.org/Eclipse_(logiciel)/


Schéma XML (XML Schema, XSD)

La définition de schéma XML se réalise par l'intermédiaire de plusieurs éléments chargés de représenter l'arborescence et les informations d'un document XML.

L'élément racine d'un schéma XML (schema) peut incorporer des schémas extérieurs avec un espace de noms identique ou différent.

Les éléments et les attributs XML sont chacun spécifiquement représentés dans un schéma. Il est possible de les regrouper pour des raisons de commodités, ou encore de représenter des nœuds XML indéfinis par des éléments de schéma génériques.

Exemple de syntaxe XSD :


<?xml version="1.0" encoding="UTF-8"?><schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.example.org/GolfCountryClub" xmlns:tns="http://www.example.org/GolfCountryClub"> <element name="GolfCountryClub"> <complexType> <sequence> <element name="GolfCourse" type="tns:GolfCourseType" maxOccurs="unbounded" minOccurs="1"></element> <element name="Member" maxOccurs="unbounded" minOccurs="1"> <complexType> <choice> <element name="RestrictedMember" type="tns:RestrictedMemberType"></element> <element name="RegularMember" type="tns:RegularMemberType"></element> <element name="ExclusiveMember" type="tns:ExclusiveMemberType"> <annotation> <documentation>Life-time member</documentation> </annotation> </element> </choice> <attribute name="handicap" type="nonNegativeInteger"></attribute> </complexType> </element> <element name="Employee" type="tns:EmployeeType" maxOccurs="unbounded" minOccurs="1"></element> <element name="ProShop"> <complexType> <sequence> <element name="GolfClub" type="tns:GolfClubType" maxOccurs="unbounded" minOccurs="1"></element> <element name="BoxOfBalls" maxOccurs="unbounded" minOccurs="1" type="tns:BoxOfBallsType"></element> </sequence> </complexType> </element> </sequence> </complexType> </element></schema>


Diagramme de classes

C’est un schéma utilisé en génie logiciel pour présenter les classes et les interfaces d'un système ainsi que les différentes relations entre celles-ci. Ce diagramme appartient à la partie statique d'UML car il fait abstraction des aspects temporels et dynamiques.

Voici ci-dessous un diagramme de classes que nous avons étudié (exemple du Golf Country Club). Il est l’équivalent graphique des quelques lignes tirées du fichier XSD précédent.



Diagramme d’objets

Le diagramme d’objets permet de représenter les instances des classes, c'est-à-dire des objets. Comme le diagramme de classes, il exprime les relations qui existent entre les objets, mais aussi l'état des objets, ce qui permet d'exprimer des contextes d'exécution. En ce sens, ce diagramme est moins général que le diagramme de classes. Une partie du diagramme objet que nous avons étudié (exemple du Golf Country Club) :

Ce diagramme objet correspond aux lignes suivantes du fichier XML du Golf Country Club :


<Member handicap="20"> <RegularMember> <FirstName>Keith</FirstName> <LastName>Chong</LastName> <MembershipExpiry>2010-10-31</MembershipExpiry> </RegularMember> </Member> <Member handicap="0"> <ExclusiveMember> <FirstName>James</FirstName> <MiddleName>Lion</MiddleName> <LastName>Chan</LastName> <ValetParkingID>124</ValetParkingID> <LockerNumber>10</LockerNumber> </ExclusiveMember> </Member> <Member handicap="25"> <RestrictedMember> <FirstName>Allan</FirstName> <LastName>Chong</LastName> <MembershipExpiry>2010-10-31</MembershipExpiry> <LimitedPlay>Weekend Only</LimitedPlay> </RestrictedMember> </Member> <Member handicap="10"> <RegularMember> <FirstName>Murray</FirstName> <MiddleName>Izzun</MiddleName> <LastName>Beaton</LastName> <MembershipExpiry>2010-09-30</MembershipExpiry> </RegularMember> </Member>


XML Metadata Interchange (XMI)

XMI est un standard pour l’échange de métadonnées UML basées sur XML.

Dans notre projet, avec l’utilisation d’hyperModel, les diagrammes de classes ou d’objets UML 2.0 sont exportés avec l’extension XMI.

2.2.Relevés de décisions

Nous utilisons actuellement un cycle de vie logiciel incrémental. En effet, nous travaillons sur une application Eclipse à laquelle nous ajoutons petit à petit des fonctionnalités au fur et à mesure de nos recherches.



3. Participation des services utilisateurs

3.1.Les commanditaires du projet

Le commanditaire de ce projet est Monsieur Thierry Nodenot. Il est chercheur à l’Université de Pau et des Pays de l’Adour et est intervenant dans le département GEA de l’IUT de Bayonne.

3.2.Les utilisateurs du projet

Les utilisateurs de ce projet sont essentiellement Thierry Nodenot et les utilisateurs de la base de données Exist établie à Pau.

3.3.Les financeurs du projet

La plateforme Eclipse étant en Open Source, son utilisation est libre et gratuite. Par conséquent, notre projet ne nécessite aucun coût particulier si ce n’est celui lié au temps que nous accorde notre tuteur et commanditaire. Nous n'avons donc aucunement besoin de financement pour la réalisation de notre projet.IUT DE BAYONNE – DÉPARTEMENT INFORMATIQUE 14


4. Champ du projet

4.1.Cadre stratégique

Lors de nos réunions avec notre tuteur/commanditaire M. Thierry Nodenot, nous nous sommes dans un premier temps consacré à l’apprentissage du logiciel Eclipse (savoir l’utiliser, essayer ses fonctionnalités, etc.). Mais aussi, nous avons également dû nous familiariser avec les langages XML et XSD ainsi qu’avec la création d’applications et de plug-ins Eclipse.

Ensuite, l’apprentissage de l’utilisation du XMI sera nécessaire pour pouvoir transcrire un fichier XML/XSD en diagramme d’objets/de classes UML 2.0.

4.2.Objectifs de gestion

Notre application doit gérer un système de « Projets » (c'est à dire gérer des dossiers liés les uns aux autres et qui contiennent différents fichiers XML/XSD).

Notre application doit comporter un système d’importation et d’exportation de fichiers XML/XSD soit depuis un espace de travail, soit depuis la base de données Exist.

Notre application doit comporter un système d’édition de fichiers XML/XSDNotre application doit permettre à un utilisateur d’afficher un fichier XML en

diagramme objet et un fichier XSD en diagramme de classe.IUT DE BAYONNE – DÉPARTEMENT INFORMATIQUE 15


4.3.Orientations d’organisation

(a) Importation de fichiers XML et XSD via un web service depuis la base de données Exist(b) Importation de fichiers XML et XSD depuis un espace de travail(c) Exportation de fichiers XML et XSD vérifiés(d) Exportation de fichiers XML et XSD en diagrammes de classes/objets UML 2.0(e) Envoie de fichiers XML et XSD vérifiés dans la base de données Exist via un web service.

Avantages

L'application permet de vérifier les fichiers XML et XSD.L'application permet de transcrire les fichiers XML en diagramme Objet et les fichiers

XSD en diagramme des classes.

Inconvénients

Contraintes dues à la maitrise d’un web service permettant de récupérer des fichiers présents dans la base de données Exist.

Contraintes dues à la réalisation de diagramme UML 2.0 à partir de fichiers XML/XSD (Choix d’un plug-in incorporable à notre application).

Contraintes

Les contraintes auxquelles nous faisons face aujourd’hui sont celles de l’utilisation d’un web service pour avoir accès à la base de données Exist basée à Pau. Nous n’avons pas trouvé de plug-in réalisant un diagramme objet depuis un fichier XML.



5. Plan d’action

5.1.Démarche de développement

Familiarisation avec notre projet et les outils à utiliserMaîtriser Eclipse, les langages XML, XSD et XMI, comprendre l'organisation d'un

plug-in et d'une application Eclipse.

Rédaction de la charteEtape importante pour présenter notre projet, ses fonctionnalités et son but final.

ProgrammationRéalisation de notre application et de notre plug-in sous Eclipse.

TestsPendant la période de programmation, des tests seront faits pour valider nos

fonctionnalités.

Documentation finaleFinalisation des documents déjà produits ainsi que la production de la charte du projet

(version définitive).

Préparation à la soutenance oralePréparation du document au format PowerPoint, répartition des parties de notre

soutenance.



5.2.Calendrier prévisionnel

Le calendrier prévisionnel du projet se trouve en annexe 7.4.

5.3.Organisation du projet

Nous avons décidé de répartir les différentes tâches de notre projet entre les différents membres du groupe afin de mieux nous concentrer sur chacune d’entre elles.

Pour les différentes réunions avec notre tuteur/commanditaire, nous avons décidés de nommer un interlocuteur, Sylvain Rabot, afin d'établir une relation entre notre tuteur/commanditaire et le groupe de projet.



6. Bilan

Lors des mois qui ont composés ce projet nous avons étudié l’environnement de développement d’Eclipse, réalisé des plug-ins et des applications Eclipse auxquelles nous avons intégré divers plug-ins.

A l’heure actuelle, notre application est capable de récupérer un fichier XML et son XSD correspondant. Elle peut également vérifier si un fichier XML et un fichier XSD sont écrits de façon convenable. Elle peut éditer ces deux types de fichiers grâce à des éditeurs de texte spécifique à la syntaxe XML et permet de générer le diagramme de classe correspondant à un fichier XSD. Par contre, nous ne sommes pas encore parvenus à créer de diagramme d’objets correspondants aux fichiers XML. Cette application peut également exporter les fichiers XML et XSD ainsi qu’exporté les diagrammes générés en fichier XMI.

En ce qui concerne les fonctionnalités liées à la base de données Exist, nous n’avons pas été en mesure de les implémenter. En effet, nous avons monopolisé notre temps dans notre recherche du fonctionnement d’Eclipse, de ses plug-ins et des fonctions liées au XML et XSD. La complexité de l’exercice ne nous a pas permis de nous intéresser aux services web et Exist comme l’aurait souhaité notre tuteur et commanditaire. Nous regrettons d’avoir délaissé cette partie de notre projet mais il nous semblait plus important de mettre en œuvre les fonctionnalités concernant le XML et le XSD. Nous tenons à nous excuser auprès de notre tuteur et commanditaire pour avoir négligé cette partie de notre projet.

Du côté du bilan humain de notre projet, nous admettons avoir eu de sérieux problèmes de communication que ce soit entre nous et notre tuteur/commanditaire ou encore au sein même de notre groupe. Nous n'avons pas su gérer correctement les relations qui nous auraient sans doute permises de mieux nous organiser au niveau du temps et de nos objectifs et, par conséquent, d’augmenter la qualité et la quantité de travail pour ce projet. Cet échec nous a réellement fait comprendre l’importance des relations humaines au sein d’un projet et nous souhaitons aussi nous excuser auprès de Mr Thierry Nodenot pour cela.



7. Annexes

7.1.Sujet original du projet de synthèse

DÉVELOPPEMENT D'UN PLUG-IN POUR LA PLATEFORME ECLIPSE

Commanditaire (s) :

- THIERRY NODENOT

Responsable (s) de suivi :

- THIERRY NODENOT

Description précise du sujet :

Eclipse est au départ un environnement de développement d'applications Java et son évolution est maintenant gérée par la fondation Eclipse. C'est un outil très puissant que tout développeur Java se doit de connaître.

La conception de cet environnement est complètement modulaire, basée sur un moteur de chargement de plugins et de différents plugins, ce qui fait d'Eclipse une boite à outils facilement améliorable ou modifiable. C'est cette caractéristique très importante qui fait la puissance et la richesse de cette plateforme.

Le projet de synthèse consiste à prendre en main la plateforme Eclipse, à utiliser des plugins existants, et à apprendre à développer un plugin répondant à un cahier des charges précis. Ce plugin ne sera pas centré "Production de code Java" mais s'appuiera sur l'Eclipse Modeling Framework (EMF) qui est particulièrement utile pour concevoir et implémenter des modèles de données structurées : ici EMF nous servira à transformer des documents XML en diagrammes de classes/objets UML 2.0

Le plugin offrira les fonctionnalités suivantes :

Il rendra possible la manipulation (ouverture, visualisation) de fichiers XML et de leur DTD associée (accès local / accès en tant que client Exist).

Il permettra de vérifier la conformité du fichier XML par rapport à sa DTD et d'effectuer des opérations de base sur ce fichier.

Il permettra de transformer le fichier XML en une représentation exploitable par un outil de visualisation de diagrammes de classes/objets UML. Cet outil ne sera pas à développer puisque des éditeurs UML tels Topcased ou Omondo sont disponibles sous forme de plugin Eclipse.

Le plugin sera validé par un jeu de tests : tests unitaires (à définir par les membres du projet), tests en vraie grandeur à partir d'un ensemble de ressources documentaires sur le Béarn ayant été OCR-isées balisées en XML (balisage des informations géographiques



contenues dans ces documents).

Mots-clés : Java, XML, XMI, UML, EMF, Plugins Eclipse

Matériel(s) nécessaire(s) :

PCs sous Windows ou Linux

Logiciel(s) nécessaires(s) :

Environnement Eclipse (et autres plugins) que les étudiants pourront télécharger sur le web (Eclipse se présente sous la forme d'un programme java).



7.2.Comptes rendus de réunions

Réunion du 02/10/2006

Ordre du jour : Premier contact avec notre tuteur/commanditaire et explications supplémentaires du sujet

Lors de cette réunion notre commanditaire nous a demandé de télécharger Eclipse car il est en Open Source, il nous a demandé également de l'utiliser pour coder en Java à partir de TD/TP vus en cours. Nous devions également nous informer sur le format XML, c'est à dire récupérer un fichier XML, l'afficher dans un environnement adapté et de se familiariser avec ce nouveau langage.

A la fin de cette réunion, notre tuteur souhaite qu'avant chaque réunion nous lui fassions parvenir un document résumant l'avancement de nos connaissances du sujet et donc du projet. Il nous a demandé de concevoir un planning répertoriant nos actions au sein du projet.


Ordre du jour : Avancement de notre connaissance du sujetNous avons exprimé l'état de notre avancement à notre tuteur. Il nous a alors demandé

de nous focaliser essentiellement sur les fonctions d'extensibilité d'Eclipse via la création de plugins.Pour y parvenir, nous devons tout d'abord apprendre à installer des plugins pré-existants et à les utiliser grâce à des tutoriels disponibles sur internet.

Ensuite nous devons apprendre à créer et utiliser "Eclipse application". Il nous a demandé de lui remettre un rapport exprimant les différences entre Eclipse et les applications Eclipse. Nous devons parfaitement maîtriser Eclipse, Omondo, les plug-ins et XML avant le 15 décembre 2006.


Ordre du jour : présentation de l’étude sur l’environnement Eclipse, la création de plug-ins et d’applications Eclipse.

Nous avons présenté nos documents (disponibles en annexe) à notre tuteur et commanditaire.

Notre organisation a été remise en cause et suite à cette réunion, nous avons essayé d’orienter chacun nos recherche vers un aspect particulier du projet. Franck s’occupera essentiellement de l’étude des fichiers XML et XSD, Sylvain des applications Eclipse et Ugo des plug-ins.

Nous devons pour la prochaine réunion avoir réalisé une application Eclipse utilisant des plug-ins et présenter ce que sont les fichiers XML et XML Schema (XSD).


Ordre du jour : présentation d’une application Eclipse utilisant des plug-ins et d’une documentation sur les fichiers XML et XSD

Nous avons présenté à notre tuteur une application Eclipse fonctionnelle ainsi qu’une IUT DE BAYONNE – DÉPARTEMENT INFORMATIQUE 22


documentation sur les fichiers XML et XSD.Monsieur Thierry Nodenot nous a montré un exemple de fichier XML accompagné

par un XSD et un diagramme de classes (Exemple du Golf Country Club). Il nous a également montré l’existence d’un plug-in Eclipse permettant à un utilisateur de manipuler les fichiers XML et XSD à partir de la plateforme Eclipse.

Lors de notre prochaine réunion, nous aurons vérifié que le diagramme de classes est en accord avec le fichier XSD donné. Et nous devrons insérer dans une application Eclipse le plug-in WST que notre tuteur et commanditaire nous a précédemment montré.


Ordre du jour : Etat d’avancement du projet.Nous avons présenté un diagramme objet correspondant au fichier XML sur papier et

nous n’avions pas réellement trouvé d’erreur entre le fichier XSD et le diagramme de classes fournit. Cependant notre tuteur nous a fait remarquer une anomalie de réalisation du diagramme.

Pour ce qui est de l’intégration de WST à une application, nous n’y sommes pas parvenus. Monsieur Thierry Nodenot nous a alors dit de ne plus y faire attention car il regarderait ca. Cependant nous devons toujours travailler sur WST et ajouter un plug-in permettant de forcer la validation d’un fichier XML.


Ordre du jour : Problème dans l’avancement du projet.Dans cette réunion, nous avons expliqué à notre tuteur commanditaire les problèmes

que nous n’arrivions pas à résoudre. Celui-ci nous a demandé de nous focaliser sur une fonctionnalité de notre application qui est la validation d’un fichier XML, c’est-à-dire de savoir si le fichier XML est valide et si ce fichier a un fichier XSD qui lui est associé.


Ordre du jour : Evaluation de la charte de projet.Nous avions envoyé notre charte à notre tuteur afin de la faire valider. Cependant la

version présentée n’était absolument pas conforme et nous avions oublié de mettre à jour certaines parties avant de lui faire parvenir.



7.3.Documentation supplémentaire sur Eclipse, création d’un plug-in et d’une application

7.3.1. Présentation d’Eclipse

Eclipse est un IDE (Integrated Development Environment) ou environnement de développement intégré. Ce programme est une plateforme hautement modulable dont le but est l’aide au développement de projets informatiques.

7.3.1.1. Historique

A l’origine, la plateforme Eclipse a été créée et développée par la société IBM qui a offert le projet à la communauté des développeurs le 5 novembre 2001 en passant le logiciel sous licence Open-Source. Le montant de ce cadeau au monde du logiciel libre a été estimé à près de 40 millions de dollars. Depuis c’est la Fondation Eclipse qui s’occupe du développement d’Eclipse. A sa création, le bureau de la Fondation Eclipse était composé par un consortium de 8 entreprises : Borland, IBM, MERANT, QNX Software Systems, Rational Software, Red Hat, SuSE, TogetherSoft et Webgain. De nos jours le consortium d’entreprises membre de la fondation dépasse le nombre de 80.

7.3.1.2. Fondements

Le principal point fort d’Eclipse est son aptitude à pouvoir évoluer. Ce logiciel a été conçu de telle sorte que toutes les fonctionnalités du logiciel proviennent de modules appelés « plug-ins ». En effet, à part l’application de base « runtime », tout le reste de la plateforme est codé sous forme de plug-in. Nous développerons plus cette notion dans la partie dédiée à la conception de plug-ins Eclipse (Voir 2. Les plug-ins d’Eclipse).

7.3.1.3. Standard Widget Toolkit

Contrairement à bon nombre d’applications Java, l’interface homme-machine d’Eclipse a été développée avec la bibliothèque graphique SWT (Standard Widget Toolkit) créée par IBM pour concurrencer Swing / AWT. Cette bibliothèque a pour particularité de reprendre les éléments graphiques propres au système d’exploitation utilisé par l’utilisateur, ce qui fait que les applications basées sur SWT ne ressemblent pas aux applications java « standards ». De plus cette bibliothèque a l’avantage non négligeable d’être beaucoup plus performante que Swing.

7.3.1.4. Le Workbrench

Le développement sous Eclipse se fait sous la forme de projets qui regroupent tous les fichiers de code relatif à chaque programme. Les projets sont enregistrés avec les fichiers qui le composent dans le « Workbrench ». Le « Workbrench » ou espace de travail est un dossier dont l’emplacement est défini par l’utilisateur. Chaque projet est représenté par une arborescence de dossiers et de fichiers dans le « Workbrench ».



7.3.1.5. Les perspectives

Eclipse possède un système de perspective. Les perspectives sont des interfaces graphiques dédiées à une utilisation bien précise. Nous pouvons citer comme exemple la perspective Java qui sert au développement Java (exemple ci-dessous), la perspective de création de plug-in, la perspective de débogage, etc.

7.3.1.6. Liens

Eclipse : http://www.eclipse.org/ Fondation Eclipse : http://www.eclipse.org/org/foundation/ SWT : http://www.eclipse.org/swt/


http://www.eclipse.org/swt/

http://www.eclipse.org/org/foundation/

http://www.eclipse.org/


7.3.2. Les plug-ins Eclipse

7.3.2.1. Présentation

Eclipse est une plateforme permettant de créer une multitude de plug-ins. Un plug-in est employé pour désigner un programme qui interagit avec un logiciel principal pour lui apporter de nouvelles fonctionnalités. Un plug-in ne peut fonctionner seul car il est uniquement destiné à apporter une fonctionnalité à un ou plusieurs logiciels. Sous Eclipse, un plug-in prend la forme d’une librairie .jar .

Les personnes ayant mis au point le plug-in n’ont pas nécessairement de relation avec les auteurs du logiciel principal, ce qui augmente les possibilités d’évolution et d’extension du logiciel utilisant les plug-ins.

7.3.2.2. Création d’un plug-in Eclipse (Hello world!)

Eclipse possède par défaut un assistant permettant de développer rapidement un plug-in fonctionnel évitant au programmeur l’écriture de nombreuses classes. Première étape : la création du projet contenant le plug-inTout d’abord, cliquez sur « Fichier » puis « Nouveau » puis « Projet ». La boîte de dialogue ci-dessous va s’ouvrir. Cliquez alors sur « Projet de plug-in » dans la liste puis sur le bouton « Suivant ».

Un nouvel écran apparaît remplissez alors les champs disponibles.



C’est lors de cette étape que nous allons nommer notre projet (ici MonPlugin). Il peut être choisi tout à fait librement.Deuxième étape : Remplissage des champs liés au plug-in

C’est lors de cette étape que nous allons saisir le nom du plug-in, la version ou le nom de la librairie jar qui sera créée lorsque nous déploierons le plug-in.Troisième étape : Création d’un plug-in à partir d’un modèle



Cette étape permet de créer un plug-in à partir de modèles préexistants. Nous pouvons également grâce à cette page créer un plug-in de A à Z en décochant simplement la case « Créer un plug-in à l’aide de l’un des modèles », cependant cette dernière possibilité est réservée aux utilisateurs expérimentés en Java et dans al manipulation d’Eclipse.

Pour notre exemple nous avons décidé d’utiliser l’assistant de plug-in personnalisé. Ci-dessous, la représentation des divers choix que nous propose l’assistant.



L’étape suivante nous permet de renseigner des champs concernant les paquetages (packages) d’actions lés au plug-in (nom du paquetage, de la classe, etc.). Ci-dessous, les exemples liés à la création du jeu d’action « Hello world ! » et de l’exemple de menu.



Pour finir, cliquez sur « Terminer », Eclipse créera un nouveau projet dans « l’explorateur de packages » (à gauche par défaut, voir ci-dessous) et une page s’ouvrira sur votre plan de travail Eclipse.



Le plug-in est maintenant prêt à être exporté, puis inséré dans Eclipse.



7.3.2.3. Exportation d’un plug-in

Avec un clique-droit sur le projet puis « Exporter », vous ouvrez une fenêtre d’exportation de plug-ins. Vous choisissez la manière dont sera exporté le plug-in puis vous validez.



Voici enfin le résultat produit par le plug-in, avec pour commencer une visualisation de la barre de menu avant l'utilisation du plug-in et une après.

Nous pouvons constater l'apparition d'une icone supplémentaire ainsi que d'un menu.

Lors de l’utilisation de ce menu ou en cliquant simplement sur l’icône qui est apparue, nous obtenons le résultat suivant.



7.3.3. Les applications Eclipse

7.3.3.1. Introduction

Ce rapport a pour but de montrer les étapes nécessaires à l'exportation d'une application Eclipse RCP. Pour cela nous commencerons d'abord à créer une application modèle grâce aux exemples fournis avec Eclipse. Ensuite nous verrons la marche à suivre pour exporter cette application dans le but de pouvoir l'exécuter en dehors d'Eclipse. Dans le but d'être le plus clair possible, toute la démarche est illustrée de captures d'écrans montrant la marche à suivre.

7.3.3.2. Création d’une application modèle

Nous allons créer un pseudo client e-mail. En effet, l'exemple fourni avec Eclipse n'implémente aucune fonctionnalité, il s'agit juste d'un exemple pour montrer l'architecture d'une application Eclipse. Nous nous en servirons pour décortiquer le processus d'exportation.

Pour commencer, créez un nouveau projet en vous rendant dans le menu " File ", " New ", et " Project ".



Sélectionnez " Plug-in Project " et cliquez sur " Next ".

Donnez un nom à votre projet, ici, " Projet Modèle " et cliquez sur " Next ".



Sur cette fenêtre, sélectionnez " Yes " pour créer une application RCP au lieu de créer un plug-in standard.

Sélectionnez " RCP Mail Template " et cliquez sur " Finish ".



Vous avez fini de créer votre application Eclipse, vous pouvez la lancer en cliquant sur " Launch an Eclipse Application ".



7.3.3.3. Exportation d’une application

Maintenant que l'application est prête, nous allons pouvoir l'exporter, pour cela il faut créer un fichier de type " .product " qui va servir à contenir les directives de compilation de l'application.

Faites un clique-droit sur le nom de votre projet, cliquez sur " New " puis sur " Product Configuration "



Remplissez le champ " file name " avec " projet_model.product " et sélectionnez l'option " Create a configuration file with basic settings " et cliquez sur " finish".

Le fichier " projet_model.product " a été créé. Il vous faut maintenant le configurer avant de pouvoir exporter votre application. Pour cela remplissez les champs vides comme je l'ai fait sur la capture d'écran suivante et sauvegardez le projet_modele.product.



Toujours dans le .product nous allons maintenant modifier l'onglet " Configuration " situé en bas à droite de la vue montrée dans la capture d'écran ci-dessus.

Dans cet onglet, cliquez sur le bouton " Add ", et sélectionnez dans la liste le nom de votre projet, ici, " Projet_modele " et cliquez sur " ok ".



Ensuite cliquez sur le bouton " Add required Plug-ins ", cela va rajouter à la liste tous les paquetages dont votre application Eclipse a besoin pour fonctionner après l'exportation.

Sachez qu'à chaque fois que vous modifiez votre application il est préférable que vous refassiez cette opération après avoir, au préalable, supprimé tous les paquetages de la liste en cliquant sur " Remove all ". Sauvegardez le .product.



Maintenant nous allons repasser dans l'onglet " Overview " pour procéder à l'exportation de l'application. Une fois dans l’onglet " Overview " cliquez sur le lien " Synchronize " et sur " Launch the product " pour vérifier que l'application se lance correctement. Puis cliquez sur le lien " Eclipse product export wizard " pour commencer l'exportation.



Une fenêtre vient de s'ouvrir, sélectionnez l'endroit où vous voulez exporter l'application dans le champ " Directory " et cliquez sur " finish ".

Voilà c'est fini. Il vous suffit maintenant de vous rendre dans le répertoire où vous avez choisi d'exporter votre application et de lancer l'exécutable.



7.4. Diagramme de Gantt du projet


[dÉveloppement d'un plugin pour la ...nihil.is.free.fr/root/eclipse/charte de projet.docx ·...

Documents