|
Eclipse RCP
3.Deuxième exemple
Nous allons partir de notre première application puisque toutes les classes de bases y sont déjà présentes (Application, Workbench Advisor…) et la modifier pour réaliser une application un peu plus compliquée avec plusieurs vues, un menu et différentes actions sur ces menus.
Nous allons donc d’abord modifier la classe ApplicationWorckbenchAdvisor.java afin de changer le titre et la taille de la fenêtre et spécifier que la barre de menu doit être visible :
public void preWindowOpen() {
IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
configurer.setInitialSize(new Point(1000, 800));
configurer.setShowMenuBar(true);
configurer.setShowCoolBar(false);
configurer.setShowStatusLine(false);
configurer.setTitle("Application Eclipse RCP");
}
Il faut ensuite ajouter plusieurs vues sur notre application. Il faut donc modifier la classe Perspective.java qui contient l’ensemble des vues :
public void createInitialLayout(IPageLayout layout)
{
/* On cache l'éditeur qui est placé par défaut
par eclipse RCP */
String editorArea = layout.getEditorArea();
layout.setEditorAreaVisible(false);
// On ajoute deux nouvelles vues
IFolderLayout folder = layout.createFolder("Onglets", IPageLayout.TOP, 0.5f, editorArea);
folder.addPlaceholder(MyView.ID + ":*");
folder.addView(MyView.ID);
//une vue à droite
layout.addStandaloneView(MyViewRight.ID, false,IPageLayout.RIGHT, 1.0f, IPageLayout.ID_EDITOR_AREA);
layout.getViewLayout(MyViewRight.ID).setCloseable(true);
}
On a ici caché la vue qu’affiche Eclipse RCP par défaut puis nous avons défini une vue à partir de l’interface IFolderLayout (qui permet d’afficher un éditeur avec un système d’onglets comme dans Eclipse) qui sera affiché en haut à gauche (IPageLayout.TOP). La deuxième vue est une vue simple, qui sera située sur la droite de l’application.
La dernière ligne permet d’empêcher la fermeture de la vue de droite.
A noter qu’à chaque fois, les méthodes addView et addStandaloneView (c’est une vue qui ne peut être arimée) prennent comme paramètre l’ID de la vue qui sera affiché. Lors de l’exécution, le runtime va alors aller chercher dans le fichier plug-in.xml l’id de la vue et va instancier la classe correspondante.
Il faut donc aller ajouter dans plug-in.xml un nouvel élément View (vue) avec comme paramètre la classe correspondante à cette vue. Pour cela, il faut retourner sur l’interface de développement de plug-in (PDE) dans l’onglet « extensions ».
Pour ajouter une nouvelle vue, il faut cliquer sur Add, sélectionner org.eclipse.ui.views puis cliquer sur Finish. Il faut ensuite donner un identifiant à notre vue (par exemple « myview ») et un nom (« myview » également). Il faut aussi préciser à quelle classe cette vue correspond. Il faut donc aller dans l’onglet plugin.xml et ajouter le nom de la classe à l’endroit où l’assistant a décrit notre vue :
<extension id="com.supinfo.eclipseRCP.exemple.MyView" point="org.eclipse.ui.views">
<view id="myview" name="myview" class="com.supinfo.eclipseRCP.exemple.MyView">
</view>
</extension>
La procédure pour la seconde vue est la même sauf qu’il faut indiquer « myviewright » comme id et comme nom et ajouter la ligne suivante dans le fichier plugin.xml :
>.
Il nous reste plus qu’à créer les classes MyView et MyViewRight.
Il faut donc créer deux nouvelles classes. Ces classes héritent de la classe ViewPart et doivent redéfinir les méthode createPartControl et setFocus. Il faut également déclarer une chaîne ID qui représente l’identifiant de la classe (celui présent dans plugin.xml). Il est ensuite possible sur chaque vue d’utiliser n’importe quel composant graphique de SWT. A noter qu’il est possible d’utiliser un plug-in comme Visual Editor ou Jigloo pour réaliser ses vues en drag and drop.
Par exemple, sur la vue de droite nous créons un canvas sur lequel on place un label.
public class MyViewRight extends ViewPart
{
public static final String ID = "myviewright";
private Canvas canvas;
private Label lbTest;
public void createPartControl(Composite parent)
{
canvas = new Canvas(parent, SWT.Paint);
{
lbTest = new Label(canvas, SWT.NONE);
lbTest.setText("Un Label");
lbTest.setBounds(4, 4, 40, 18);
}
}
public void setFocus() {}
}
Maintenant que les vues sont définies, il faut remplir la barre de menu puisque nous l’avons définie comme visible dans la classe ApplicationWorkbenchWindowAdvisor. Pour cela, il faut éditer la classe ApplicationActionBarAdvisor. Cette classe est donc composée de différentes méthodes qui permettent de remplir les « Action bar » et de définir des actions à exécuter pour chacun des menus.
Il faut d’abord remplir la barre de menu :
protected void fillMenuBar(IMenuManager menuBar)
{
MenuManager fileMenu = new MenuManager("&Fichier", IWorkbenchActionConstants.M_FILE);
MenuManager helpMenu = new MenuManager("&A propos", IWorkbenchActionConstants.M_HELP);
menuBar.add(fileMenu);
menuBar.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
menuBar.add(helpMenu);
// Fichier
fileMenu.add(newWindowAction);
fileMenu.add(openViewAction);
fileMenu.add(new Separator());
fileMenu.add(exitAction);
// A propos
helpMenu.add(aboutAction);
}
Ici nous utilisons les MenuManager de JFace qui permettent de gérer nos menus. On ajoute ensuite les menuManager à la barre de menu et, pour chaque menu, on ajoute des items sous formes d’instances de classes Actions (par exemple, openViewAction). Le rôle de ces classes est de rediriger toutes les actions possibles de l’utilisateur final (touches clavier, menus…) vers le code de traitement.
L’environnement fournit des actions standard comme ceux utilisés ici dans la méthode makeActions (par exemple la ligne newWindowAction = ActionFactory.OPEN_NEW_WINDOW.create(window) va créer une deuxième instance de l’ application en cours dans une nouvelle fenêtre lorsque l’utilisateur cliquera sur ce menu).
protected void makeActions(IWorkbenchWindow window)
{
exitAction = ActionFactory.QUIT.create(window);
register(exitAction);
aboutAction = ActionFactory.ABOUT.create(window);
register(aboutAction);
newWindowAction = ActionFactory.OPEN_NEW_WINDOW.create(window);
register(newWindowAction);
openViewAction = new OpenViewAction(window, "Ouvrir un nouvel onglet", MyView.ID);
register(openViewAction);
}
Il est également possible de créer ses propres actions. C’est ce qui est fait ici avec l’Action OpenViewAction. Il faut alors créer une nouvelle classe dérivant de la classe Action :
public class OpenViewAction extends Action {
private final IWorkbenchWindow window;
private int instanceNum = 0;
private final String viewId;
public OpenViewAction(IWorkbenchWindow window, String label, String viewId) {
this.window = window;
this.viewId = viewId;
setText(label);
setId(“onglet.open”);
setActionDefinitionId(“onglet.open”);
}
public void run() {
if(window != null) {
try {
window.getActivePage().showView(viewId, Integer.toString(instanceNum++), IWorkbenchPage.VIEW_ACTIVATE);
} catch (Exception e) {
MessageDialog.openError(window.getShell(), "Error", "Error opening view:" + e.getMessage());
}
}
}
}
Le constructeur prend comme paramètre l’instance de la fenêtre en cours, un label pour le menu et la vue dont il faut créer une nouvelle instance. Ici il s’agit de la vue centrale, l’action du clique sur ce menu permettra donc de créer un nouvel onglet sur notre vue de gauche.
L’application est terminée. Pour tester son fonctionnement, il est possible de cliquer sur « Launch an Eclipse application » sur l’assistant de création de plug-in.
L’application réalisée avec Eclipse RCP
Il existe un assistant pour pouvoir exporter notre application pour qu’elle puisse être exécutable à l’extérieur d’Eclipse.
La procédure à réaliser est la suivante : Clique droit sur le projet, New, Product configuration. Il faut donner un nom de ficher à l’application (par exemple « ApplicationRCP.product »). Dans l’assistant qui apparaît, il faut cliquer sur New, choisir le projet à exporter et donner un ID (par exemple « ApplicationRCP.product »).
Il faut ensuite aller dans l’onglet configuration et cliquer sur « Add required plugin » .
En revenant sur l’onglet « Overview », il est maintenant possible d’exporter l’application en cliquant sur « Eclipse Product Application Wizard », dans l’assistant dans « Export destination », il faut selectionner Directory et naviguer jusqu’au dossier où vous voulez exporter l’application.
L’assistant crée ensuite un dossier qui contient tous les jar requis pour votre application (swt, jface) ainsi qu’un .exe et un .jar pour lancer votre application.
|
|
 |
|
