ECLIPSE RCP

Introduction

Gaël QUEMENERIfremerFé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?........................................................................................................................ 114.1.1 Modularité.................................................................................................................................... 114.1.2 Extensibilité.................................................................................................................................. 114.1.3 Partageabilité............................................................................................................................... 11

4.2 OSGI.................................................................................................................................................... 114.2.1 Bundles OSGi et dépendances....................................................................................................124.2.2 Versioning.................................................................................................................................... 124.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...................................................................................................135.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 .................................................................................................................................. 328.3.1 Les différents layouts SWT..........................................................................................................328.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 deplug-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 HistoriqueEclipse 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.

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

Figure 1: Architecture

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

Exemples d'outils:

• Eclipse RCP,

• Netbeans RCP,

• Spring Framework,

• Microsoft .net Rich Client Applications

1.4 ModélisationPlusieurs 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

UML : Unified Model Language

BPMN : Business Process Model and Notation (modèle de processus métier)

7/37

Figure 2: Eclipse Modeling Framework

Figure 3: UML

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érequisPour 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 4: BPMN

3. Workbench

3.1 DéfinitionQuand 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

Figure 5: Eclipse Workbench preferences, Installed JREs

• 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 VersioningOSGi 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-ActivatorOptionel, definit un Activator. Cette classe sera appelées à l'activation du bundle.

Bundle-RequiredExecutionEnvironmentSpecifie la version de Java requise. Si cette condition n'est pasremplie, le runtime OSGI ne charge pas le bundle.

Bundle-ActivationPolicyMode 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-win32-x86_64.zip

pour linux :

http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/kepler/SR1/eclipse-rcp-kepler-SR1-linux-gtk-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-macosx-cocoa-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 toolsCes 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...

Choisir un projet de type "Eclipse 4 Application Project" :

15/37

Figure 7: Création d'un nouveau projet

Entrer comme Project Name : myfirstappli. Laisser les options comme dans la figure ci-dessous.

16/37

Figure 8: Projet "Eclipse 4 Application Project"

Cliquer sur "Next".

La page Contents apparait, vérifier que les paramètres sont semblables à ceux de la figure ci-dessous:

17/37

Figure 9: Nouveau projet plug-in

Laisser les paramètres par défaut dans la page e4 Application comme sur la figure ci-dessous:

18/37

Figure 10: Content

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 :

Double cliquer sur le fichier myfirstappli.product.

On voit apparaitre la vue suivante :

20/37

Figure 12: Représentation du projet dans le PackageExplorer

Cliquer sur Launch an Eclipse application.

L'application est lancée :

21/37

Figure 13: Edition du fichier .product

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 exempledes 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 14: Première application

7.2 Ajouter une perspective Sélectionner le noeud Controls et ajouter une Perspective Stack.

23/37

Figure 15: Modèle d'application Application.e4xmi

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

La page de configuration d'une nouvelle vue apparait, lui donner le label SWT comme ci-dessous:

27/37

Figure 20: Création d'une nouvelle Part

Figure 21: Configuration d'une Part

Dans le Package Explorer, cliquer droit sur le fichier myfirstappli.product et cliquer sur Run As-Run configurations.

La fenêtre suivante apparaît:

Cocher la case Clear et workspace comme ci-dessus.

Cliquer sur "Apply" puis "Run".

On voit apparaître notre nouvelle vue:

28/37

Figure 22: Nettoyage du workspace

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 23: Nouvelle Part dans une application

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 24: Création d'une nouvelle classe

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 org.eclipse.swt.SWT;import org.eclipse.swt.awt.SWT_AWT;import org.eclipse.swt.browser.Browser;import org.eclipse.swt.layout.GridData;import org.eclipse.swt.widgets.Composite;

public class SWTPart {

@Injectpublic void init(Composite parent) {

final Browser b = new Browser(parent, SWT.NONE); b.setUrl("www.youtube.com/");

}

}

Relancez l'application.

31/37

Figure 25: Déclaration de la classe contribuant à une Part

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. Ilfournit des widgets, p.ex. des boutons et des champs de texte, ainsi que des layout managers, qui gèrent ladisposition des widgets dans une fenêtre. Les layout managers sont utilisés pour organiser les widgets selonun ensemble de règles.

SWT prend en charge plusieurs plates-formes, par exemple Windows, Linux et Mac OS X. L'objectif deconception de SWT est de rester étroitement au système d'exploitation (OS), donc l'API SWT (ApplicationProgramming 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 , interfacede plus haut niveau.

SWT utilise les widgets natifs de la plate-forme dès que possible. SWT accède aux widgets natifs de l'OSvia le framework Java Native Interface. Le Java Native Interface (JNI) est un framework qui permet aucode Java exécuté dans une machine virtuelle Java (JVM) d'appeler et d'être appelé par des applicationsnatives 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'interfaceutilisateur disponible en Java. SWT fournit plus de widgets qu'AWT. Dans le cas où un widget n'est pasdisponible 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 bouclesd'événements, pour contrôler la communication entre le thread d'interface utilisateur et d'autres threads, dela 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 SWTUn layout manager est un gestionnaire de mise en page, il sert à placer les différents widgets dans unefenêtre.

Types de layout SWT :

32/37

Layout Manager Description

AbsoluteLayoutPermet 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.

RowLayoutWidgets 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, horizontalSpan, verticalSpan)

Les attributs les plus importants sont définis comme suit:

Parameter Description

horizontalAlignmenthow the control will be positioned horizontally within a cell, one of:SWT.LEFT,SWT.CENTER,SWT.RIGHT, or SWT.FILL

verticalAlignmenthow the control will be positioned vertically within a cell, one of: SWT.TOP,SWT.CENTER,SWT.END(same as SWT.BOTTOM), or SWT.FILL

grabExcessHorizontalSpacewhether 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 codeReprenez le code de la méthode SWTPart.init:

@Injectpublic void init(Composite parent) {

// creation de la grilleGridLayout layout = new GridLayout(2, false);parent.setLayout(layout);

// objet textefinal 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";

@Injectpublic 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