ECLIPSE RCP Introduction Gaël QUEMENER Ifremer Février 2014 1/37
Table des matières 1. Introduction... 4 1.1 Historique... 4 1.2 Architecture... 5 1.3 Rich Client Platform... 6 1.4 Modélisation... 6 1.5 Extensions... 8 2. Eclipse et java... 8 2.1 Prérequis... 8 3. Workbench... 9 3.1 Définition... 9 3.2 Perspectives et parts... 10 3.3 La notion de projet... 10 4. Plugins... 11 4.1 Qu'est-ce qu'un plugin?... 11 4.1.1 Modularité... 11 4.1.2 Extensibilité... 11 4.1.3 Partageabilité... 11 4.2 OSGI... 11 4.2.1 Bundles OSGi et dépendances... 12 4.2.2 Versioning... 12 4.2.3 MANIFEST.MF... 12 5. Installation d'eclipse et de ses plugins... 13 5.1 Eclipse... 13 5.2 Installation des plug-ins nécessaires... 13 5.2.1 Installation des plugins e4 tools... 14 6.Première application Eclipse RCP... 15 7. Modèle d'application... 22 2/37
7.1 Qu'est-ce-que le modèle d'application?... 22 7.2Ajouter une perspective... 23 7.3Ajouter une vue... 25 7.4 Lier une vue à une classe... 29 8. SWT... 32 8.1 Généralités... 32 8.2 Display et Shell... 32 8.3 Layout Manager... 32 8.3.1 Les différents layouts SWT... 32 8.3.2 Un exemple : GridLayout... 33 8.4 Exemple de code... 34 8.5 Event listener... 35 9. Références... 36 9.1 Eclipse... 36 9.2 SWT... 36 3/37
1. Introduction Eclipse est un Environnement de Développement Intégré (IDE) open-source basé sur un système de plug-ins extensible. Il est développé en Java. Eclipse permet de développer des programmes en Java, Ada,C, C++, COBOL, Fortran, Haskell, Perl, PHP, Python, R, Ruby, Ruby on Rails, Scala, Clojure, Groovy, Scheme, Mathematica... Ce document s'applique à la version Eclipse 4.3 Kepler. 1.1 Historique Eclipse a été développé par IBM dans les années 90 pour remplacer l'ide VisualAge par un outil Java. En 2001, IBM passe Eclipse en open-source. La même année est créé un consortium Eclipse (à but commercial): IBM, Borland, QNX, Rational, Red Hat, Suse,... En janvier 2004, la Fondation Eclipse est créée (association à but non lucratif): CA Google IBM Oracle SAP Blackberry Airbus BMW Cisco Ericsson Intel Nokia... 4/37
1.2 Architecture Une application Eclipse est constituée de plusieurs composants appelés plugins. L'IDE Eclipse peut-être considérée comme une application Eclipse. Figure 1: Architecture L'OSGI définit une spécification qui décrit les liens entre différents modules Java. La plateforme Eclipse utilise le framework OSGI Equinox. Le Framework Equinox permet l'utilisation dynamique de composants logiciels. SWT est la bibliothèque d'objets graphiques standard pour Eclipse. JFace propose une API au dessus de SWT. Le workbench fournit les autres fonctionnalités graphiques (perspectives, views, editors, parts, wizards, actions, preferences...). 5/37
1.3 Rich Client Platform Eclipse est un IDE RCP. Une plateforme RCP fournit au développeur des composants logiciels de base pour construire une application et le noyau exécutif pour la faire fonctionner. Il n'est pas nécessaire de redévelopper tous les éléments d'une application, d'où un gain de temps. Le développeur peut reprendre les briques qui lui sont utiles et il peut en créer ou en importer de nouvelles. Une plateforme RCP est composée à la base des éléments suivants : Un noyau (microkernel): lifecycle manager (lancement et arrêt de l'application) Un bundling framework standard A portable widget toolkit File buffers, text handling, text editors A workbench (views, editors, perspectives, wizards) Update manager Eclipse RCP, Netbeans RCP, Spring Framework, Microsoft.net Rich Client Applications Exemples d'outils: 1.4 Modélisation Plusieurs outils de modélisation sont disponibles dans Eclipse. Les trois outils de modélisations les plus communs sont : Eclipse Modeling Framework : framework de modélisation, génération de code et d'applications 6/37
Figure 2: Eclipse Modeling Framework UML : Unified Model Language Figure 3: UML BPMN : Business Process Model and Notation (modèle de processus métier) 7/37
Figure 4: BPMN 1.5 Extensions On peut ajouter de nombreux modules supplémentaires à Eclipse (langages, modélisation, gestion de configuration...) : ces modules sont disponibles sur le Eclipse Marketplace. 2. Eclipse et java Eclipse est développé en Java. Depuis la version 3.7.1, Eclipse est totalement compatible avec les spécificités du langage Java de Java SE 7. 2.1 Prérequis Pour développer du code compatible avec Java 7, on doit installer Java JRE 7. Si on exécute Eclipse pour la première fois avec un JRE Java 7, il sera utilisé par défaut. Sinon, on utilise le dialogue Windows-Preferences-Java-Installed JRE pour enregistrer le JRE. 8/37
Figure 5: Eclipse Workbench preferences, Installed JREs 3. Workbench 3.1 Définition Quand on lance Eclipse, la première chose que vous voyez est un dialogue qui vous demande l'emplacement du workspace. Le workspace est le répertoire où votre travail sera stocké. Une fois que le workspace est choisi, une fenêtre Workbench s'affiche. Cette fenêtre contient une ou plusieurs perspectives. Une perspective contient plusieurs vues, éditeurs et parts, comme le Project Explorer. On peut ouvrir plusieurs workbenchs à la fois. La première fois que vous lancez Eclipse avec ce workspace, la perspective Java est affichée avec une part "Welcome". Sur la perpective Resources, les parts suivantes sont affichées: Project explorer Outline 9/37
Tasks History Console Errors,... 3.2 Perspectives et parts Eclipse IDE contient par défaut les perspectives suivantes: Resources Java Plug-in Development CVS Repository Exploring Team Synchronizing Debug... Pour ouvrir une perspective, cliquer sur Window-Open Perspective. Une perspective est composée de plusieurs Parts, ou Views. A l'intérieur de chaque perspective, on peut ré-arranger les parts, leur changer de taille, de position, etc... On peut faire un reset de chaque perspective en cliquant sur Window-Reset Perspective. D'autres perspectives peuvent être rajoutées avec l'installation d'autres modules. 3.3 La notion de projet Il y a trois catégories de ressources dans le Workbench : les projets, les folders, et les fichiers. Un projet est le plus grand élément structurel utilisé dans le Workbench. Les projets contiennent des folders et des fichiers. Ils peuvent être créés, importés, ouverts, fermés, détruits, on peut les "builder". Les folders et fichiers peuvent être liés à des éléments du système de fichiers qui sont externes au workspace (linked resources). 10/37
4. Plugins 4.1 Qu'est-ce qu'un plugin? On utilise un plugin pour regrouper le code source en unités modulaires, extensibles et partageables. 4.1.1 Modularité Chaque plug-in contient une portion de code. Le plug-in spécifie le nom des autres plug-ins dont il a besoin pour s'exécuter, et les java packages qu'il fournit. Un produit Eclipse contiendra plusieurs plugins qui peuvent être ajoutés, remplacés ou supprimés pour modifier les fontionnalités du programme. 4.1.2 Extensibilité Les plug-ins sont extensibles par utilisation des extensions et extension points. Un plug-in peut fournir un ou plusieurs extension points pour que d'autre plug-ins peuvent ajouter cette fonctionnalité. Ce mécanisme est limité en Eclipse 4, on utilise de plus en plus le mécanisme OSGI. 4.1.3 Partageabilité Les plug-ins sont partageables. Un plug-in peut être exporté sous forme de répertoire ou de jar qui peuvent être utilisés par des applications tierces. Les plug-ins peuvent être groupés en features, utiles pour les installations et le déploiement. 4.2 OSGI OSGI : Open Services Gateway initiative OSGi est une spécification. La spécification OSGi définit un composant et modèle de service pour Java. OSGI décrit la façon dont vont communiquer les différents plug-ins entre eux. Les composants et services peuvent être activés de façon dynamique, désactivé, mis à jour et désinstallés. Un plug-in doit définir ses packages Java exportés et ses dépendances requises. OSGi a plusieurs implémentations, par exemple Eclipse Equinox, Knopflerfish OSGi ou Apache Felix. 11/37
4.2.1 Bundles OSGi et dépendances La spécification OSGi définit le bundle OSGi comme unité de modularisation. Pour nous un plug-in est un bundle. Un bundle est un ensemble cohérent, une unité autonome, qui définit explicitement ses dépendances à d'autres modules et services. Il définit aussi explicitement son API externe. Techniquement les bundles OSGi sont des fichiers.jar avec des méta-données supplémentaires. Ces méta-données sont stockées sous Eclipse dans le fichier META-INF/MANIFEST.MF. Dans le fichier MANIFEST.MF, OSGi ajoute des métadonnées supplémentaires à la communication entre 2 fichiers.jar. Toute exécution non OSGi va ignorer les métadonnées OSGi. Par conséquent tout bundle OSGi peut être utilisé sans restriction dans les environnements Java non-osgi. 4.2.2 Versioning OSGi recommande d'utiliser la sémantique <major>.<minor>.<patch> 4.2.3 MANIFEST.MF Eclipse définit les paramètres OSGi d'un plug-in dans un fichier appelé MANIFEST.MF. Exemple de fichier MANIFEST.MF : Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: Popup Plug-in Bundle-SymbolicName: com.example.myosgi; singleton:=true Bundle-Version: 1.0.0 Bundle-Activator: com.example.myosgi.activator Require-Bundle: org.eclipse.ui, org.eclipse.core.runtime Bundle-ActivationPolicy: lazy Bundle-RequiredExecutionEnvironment: JavaSE-1.6 12/37
Identifiant Description Bundle-Name Description du bundle. Bundle-SymbolicName identifiant unique du bundle. Bundle-Version version du bundle Bundle-Activator Optionel, definit un Activator. Cette classe sera appelées à l'activation du bundle. Bundle-RequiredExecutionEnvironment Specifie la version de Java requise. Si cette condition n'est pas remplie, le runtime OSGI ne charge pas le bundle. Bundle-ActivationPolicy Mode lazy : le runtime OSGi runtime n'activera le bundle que lorsque une de ses classes ou interfaces sera appelée par un autre bundle. Sinon le bundle sera activé par défaut. 5. Installation d'eclipse et de ses plugins 5.1 Eclipse Télécharger Eclipse for RCP and RAP Developers 4.3 (pour windows): http://www.eclipse.org/downloads/download.php? file=/technology/epp/downloads/release/kepler/sr1/eclipse-rcp-kepler-sr1-win32x86_64.zip pour linux : http://www.eclipse.org/downloads/download.php? file=/technology/epp/downloads/release/kepler/sr1/eclipse-rcp-kepler-sr1-linuxgtk-x86_64.tar.gz ou pour MacOS : http://www.eclipse.org/downloads/download.php? file=/technology/epp/downloads/release/kepler/sr1/eclipse-rcp-kepler-sr1-macosxcocoa-x86_64.tar.gz Dézipper le fichier. 5.2 Installation des plug-ins nécessaires Lancer Eclipse. 13/37
5.2.1 Installation des plugins e4 tools Ces plugins fournissent des wizards et des édituers spécifiquent aux applications e4. Click on Help in the main Eclipse menu, then «Install New Software». Add «work with» : http://download.vogella.com/kepler/e4tools Select "Eclipse e4 core tools". Click on the «Next» button twice. Select the radio button «I accept the terms of the license agreement». Click on the «Finish» button. Figure 6: installation plugins e4 Eclipse doit être redémarré suite à cette installation de plugin. 14/37
6. Première application Eclipse RCP Créer un nouveau projet File->New->Other... Figure 7: Création d'un nouveau projet Choisir un projet de type "Eclipse 4 Application Project" : 15/37
Figure 8: Projet "Eclipse 4 Application Project" Entrer comme Project Name : myfirstappli. Laisser les options comme dans la figure ci-dessous. 16/37
Figure 9: Nouveau projet plug-in Cliquer sur "Next". La page Contents apparait, vérifier que les paramètres sont semblables à ceux de la figure ci-dessous: 17/37
Figure 10: Content Laisser les paramètres par défaut dans la page e4 Application comme sur la figure ci-dessous: 18/37
Figure 11: Eclipse 4 Application Cliquer sur "Finish". Eclipse génère le projet. 19/37
On peut maintenant voir dans le Project explorer l'arborescence du projet : Figure 12: Représentation du projet dans le Package Explorer Double cliquer sur le fichier myfirstappli.product. On voit apparaitre la vue suivante : 20/37
Figure 13: Edition du fichier.product Cliquer sur Launch an Eclipse application. L'application est lancée : 21/37
Figure 14: Première application 7. Modèle d'application 7.1 Qu'est-ce-que le modèle d'application? La partie visuelle d'une application Eclipse se compose de perspectives, Parts (Vues et éditeurs), menus, barres d'outils, etc... Une application Eclipse comprend également des composants non visuels, par exemple des Handlers, commandes et raccourcis clavier. Eclipse 4 utilise une description abstraite, appelé le modèle d'application, pour décrire la structure d'une application. Ce modèle demande contient les éléments visuels ainsi que certains éléments non visuels de l'applicatio Eclipse 4. Il est contenu dans le fichier Application.e4xmi En double-cliquant sur ce fichier, la vue suivante apparaît: 22/37
Figure 15: Modèle d'application Application.e4xmi 7.2 Ajouter une perspective Sélectionner le noeud Controls et ajouter une Perspective Stack. 23/37
Figure 16: Ajout Perspective Stack Application.e4xmi De la même façon ajouter une Perspective dans la Perspective Stack. Figure 17: Ajout Perspective Application.e4xmi 24/37
7.3 Ajouter une vue Dans le fichier Application.e4xmi, cliquer avec le bouton droit sur: Windows-Trimmed Window-Controls-Perspective Stack-Perspective-Controls Dans le menu contextuel, cliquer sur Add Child-Part Sash Container comme ci-dessous: Figure 18: Ajout Part Sash Container Application.e4xmi Ajouter une Part Stack au Part Sash Container, puis une Part à la Part Stack 25/37
Figure 19: Ajout Part Application.e4xmi 26/37
Figure 20: Création d'une nouvelle Part La page de configuration d'une nouvelle vue apparait, lui donner le label SWT comme ci-dessous: Figure 21: Configuration d'une Part 27/37
Dans le Package Explorer, cliquer droit sur le fichier myfirstappli.product et cliquer sur Run As-Run configurations. La fenêtre suivante apparaît: Figure 22: Nettoyage du workspace Cocher la case Clear et workspace comme ci-dessus. Cliquer sur "Apply" puis "Run". On voit apparaître notre nouvelle vue: 28/37
Figure 23: Nouvelle Part dans une application 7.4 Lier une vue à une classe Le but est de créer une classe java qui permettra d'ajouter des éléments graphiques à la vue dans le code. Dans le Package Explorer, cliquer droit sur le folder myfirstappli/src/myfirstappli et cliquer sur New-Class. On lui donne le nom SWTPart comme ci-dessous: 29/37
Figure 24: Création d'une nouvelle classe Cliquer sur Finish, et vérifier que le fichier SWTPart.java a bien été créé. Retourner sur la page de conficuration de la vue SWT dans Application.e4xmi, cliquer sur le bouton "Find" à droite du label "Class URI", commencer à taper "swt" dans le champ text. La complétion propose "myfirstappli.swtpart", la sélectionner comme ci-dessous, et cliquer sur OK: 30/37
Figure 25: Déclaration de la classe contribuant à une Part Retournez dans le code de SWTPart.java et faites évoluer le classe de la façon suivante : package myfirstappli; import java.awt.borderlayout; import javax.inject.inject; import import import import import org.eclipse.swt.swt; org.eclipse.swt.awt.swt_awt; org.eclipse.swt.browser.browser; org.eclipse.swt.layout.griddata; org.eclipse.swt.widgets.composite; public class SWTPart { @Inject public void init(composite parent) { final Browser b = new Browser(parent, SWT.NONE); b.seturl("www.youtube.com/"); } } Relancez l'application. 31/37
8. SWT 8.1 Généralités Le Standard Widget Toolkit (SWT) est la bibliothèque utilisée par Eclipse pour définir l'interface Utilisateur. Il fournit des widgets, p.ex. des boutons et des champs de texte, ainsi que des layout managers, qui gèrent la disposition des widgets dans une fenêtre. Les layout managers sont utilisés pour organiser les widgets selon un ensemble de règles. SWT prend en charge plusieurs plates-formes, par exemple Windows, Linux et Mac OS X. L'objectif de conception de SWT est de rester étroitement au système d'exploitation (OS), donc l'api SWT (Application Programming Interface) est très proche de l'api native du système d'exploitation. Comme l'api SWT est très rudimentaire, les programmeurs utilisent aussi généralement Jface, interface de plus haut niveau. SWT utilise les widgets natifs de la plate-forme dès que possible. SWT accède aux widgets natifs de l'os via le framework Java Native Interface. Le Java Native Interface (JNI) est un framework qui permet au code Java exécuté dans une machine virtuelle Java (JVM) d'appeler et d'être appelé par des applications natives et les bibliothèques écrites dans d'autres langages tels que C, C + + et assembleur. Des widgets natifs peuvent également être trouvés dans AWT, une bibliothèque standard d'interface utilisateur disponible en Java. SWT fournit plus de widgets qu'awt. Dans le cas où un widget n'est pas disponible sur une plate-forme, SWT l'émule. 8.2 Display et Shell Les Display et Shell classes sont des éléments clés des applications SWT. La classe org.eclipse.swt.widgets.shell représente une fenêtre. La classe org.eclipse.swt.widgets.display est responsable de la gestion des boucles d'événements, pour contrôler la communication entre le thread d'interface utilisateur et d'autres threads, de la gestion des polices et des couleurs. Chaque application SWT nécessite au moins un Display et une ou plusieurs instances Shell. Chaque Shell a pour paramètre de construction un Display. 8.3 Layout Manager 8.3.1 Les différents layouts SWT Un layout manager est un gestionnaire de mise en page, il sert à placer les différents widgets dans une fenêtre. Types de layout SWT : 32/37
Layout Manager Description AbsoluteLayout Permet de définir la position exacte, la largeur et la hauteur des composants. Lorsque des interfaces utilisateur peuvent être utilisées sur des écrans de différentes tailles, ce gestionnaire de mise en page doit être évitée. FillLayout Disposition de taille égale des widgets dans une seule ligne ou colonne. RowLayout Widgets de présentation dans une ou plusieurs lignes, avec options de fill, wrap, et les options d'espacement. GridLayout Placement des widgets dans une grille. FormLayout Widgets placés par rapport côtés de son conteneur. 8.3.2 Un exemple : GridLayout La classe GridLayout permet d'organiser les composants de l'interface utilisateur dans une grille contenant un certain nombre de colonnes et de lignes. Chaque widget doit être lié à un objet GridData. Le GridData spécifie le placement du widget dans la grille. new GridData(horizontalAlignment, verticalalignment, grabexcesshorizontalspace, grabexcessverticalspace, verticalspan) horizontalspan, Les attributs les plus importants sont définis comme suit: Parameter Description horizontalalignment how the control will be positioned horizontally within a cell, one of:swt.left,swt.center,swt.right, or SWT.FILL verticalalignment how the control will be positioned vertically within a cell, one of: SWT.TOP,SWT.CENTER,SWT.END(same as SWT.BOTTOM), or SWT.FILL grabexcesshorizontalspace whether the cell will be made wide enough to take all the remaining horizontal space grabexcessverticalspace whether cell will grab any remaining vertical space horizontalspan the number of column cells that the control will take up verticalspan the number of row cells that the control will take up heighthint heighthint specifies the preferred height in pixels widthhint widthhint specifies the preferred width in pixels 33/37
8.4 Exemple de code Reprenez le code de la méthode SWTPart.init: @Inject public void init(composite parent) { // creation de la grille GridLayout layout = new GridLayout(2, false); parent.setlayout(layout); // objet texte final Text text = new Text(parent, SWT.NONE); text.settext("www.google.com"); GridData data = new GridData(GridData.FILL, GridData.BEGINNING, true, false, 1, 1); text.setlayoutdata(data); // objet bouton Button button = new Button(parent, SWT.NONE); button.settext("go To"); data = new GridData(GridData.FILL, GridData.BEGINNING, false, false, 1, 1); button.setlayoutdata(data); } Relancer l'application et regarder le résultat. Rajoutons le browser : String httpaddress="www.google.com"; @Inject public void init(composite parent) { GridLayout layout = new GridLayout(2, false); parent.setlayout(layout); final Text text = new Text(parent, SWT.NONE); 34/37
text.settext(httpaddress); GridData data = new GridData(GridData.FILL, GridData.BEGINNING, true, false, 1, 1); text.setlayoutdata(data); Button button = new Button(parent, SWT.NONE); button.settext("go To"); data = new GridData(GridData.FILL, GridData.BEGINNING, false, false, 1, 1); button.setlayoutdata(data); final Browser b = new Browser(parent, SWT.NONE); b.seturl(httpaddress); data = new GridData(GridData.FILL, GridData.FILL, true, true, 2, 1); b.setlayoutdata(data); } 8.5 Event listener Le but est de récupérer un événement graphique. Dans notre cas, le but est de rafraîchir le browser quand on clique sur le bouton "Go To". Insérer le code suivant à la fin de la méthode init : button.addselectionlistener(new SelectionAdapter() { @Override public void widgetselected(selectionevent e) { // Handle the selection event System.out.println("Button pressed! "+text.gettext()); httpaddress=text.gettext(); b.seturl(httpaddress); } }); 35/37
9. Références 9.1 Eclipse www.eclipse.org Eclipse 4 RCP wiki: http://wiki.eclipse.org/eclipse4/rcp Eclipse 4 RCP FAQ: http://wiki.eclipse.org/eclipse4/rcp/faq Eclipse 4 wiki tutorials http://wiki.eclipse.org/eclipse4/tutorials Lars Vogel Tutorial : http://www.vogella.com/articles/eclipsercp/article.html Eclipse 4 wiki Injection de dépendances : http://wiki.eclipse.org/eclipse4/rcp/dependency_injection La "bible" Eclipse 4 : Eclipse 4 RCP: The complete guide to Eclipse application development Lars Vogel ISBN-10: 3943747077 ISBN-13: 978-3943747034 http://www.amazon.fr/eclipse-rcp-complete-application-development/dp/3943747077/ 9.2 SWT Description des widgets: http://www.eclipse.org/swt/widgets/ 36/37
Exemples de code SWT : http://www.eclipse.org/swt/snippets/ Comprendre les layouts dans SWT : http://www.eclipse.org/articles/article.php?file=article-understanding-layouts/index.html Lars Vogel SWT tutorial : http://www.vogella.com/articles/swt/article.html FIN DU DOCUMENT 37/37