Le Tutoriel Eclipse RAP pour débutant - Application e4 Workbench

L'installation requise avant de commencer
Créer une nouvelle Java Workspace
Installer RAP Target
Créer Eclipse RAP e4 Project creux
Exécuter des configurations
La structure de l'application Eclipse e4 RAP vide
Configuration supplémentaire des Bundle
Handler et Command
Créer Menus
Créer Toolbar
Part

1. L'installation requise avant de commencer

Installation d'Eclipse

You need the latest version of Eclipse. There currently is Eclipse 4.5 (Codes MARS).

↵http://eclipse.org/downloads/

In my opinion you to download package: "Eclipse IDE for Java EE Developers". The only different package quantities Plugin, for the purpose of different programming. During the programming process can install the plugin for other purposes.

Installation de WindowBuilder

Installez le Plugin WindowBuilder, il s'agit d'un plugin qui vous permet à concevoir l'interface des applications SWT GUI en glisser-déposer commodément.

Voyez les instructions de l'installation sur :

Installer WindowBuilder pour Eclipse

Installation e4 Tools Developer Resources

Vous pouvez voir les instructions de l'installation e4 Tools Developer Resources à:

Installer e4 Tools Developer Resources pour Eclipse

Installer RAP e4 Tooling dans Eclipse

Vous pouvez voir les instructions à :

Installer RAP e4 Tooling pour Eclipse

2. Créer une nouvelle Java Workspace

Pour programmer l'application de RAP e4, vous devez créer une nouvelle Java Workspace :

File/Switch Workspace/Other..

Saisissez :

F:\ECLIPSE_TUTORIAL\RAP_E4

3. Installer RAP Target

Pour programmer l'application RAP e4 vous devez installer l’environnement RAP (RAP Target Platform). Y compris au moins deux bibliothèques :

RAP Target Components
RAP e4 Target Components

Créez le projet RAPTarget et créez le fichier Target define. Vous pouvez voir les instructions à :

Installation de la plate-forme cible Eclipse RAP (RAP Target Platform)

Les résultats obtenus :

4. Créer Eclipse RAP e4 Project creux

Dans ce document, je vous donnerai des instructions de construction d'une application RAP e4 depuis le début (ne pas suivre le modèle disponible), puis je vais créer une application RAP e4 vide.

Sur Eclipse sélectionnez :

File/New/Other...

Saisissez :

Project Name: RAPe4Tutorial

Vérifier sélection sur (1)
Sur le (2) sélectionnez "No" pourque Eclipse crée un RAP Project (Exécutant sur le Web), sinon il créera RCP Project (Exécutant sur Desktop).

Sélectionnez "RAP e4 application"

Saisissez :

Application window title: Hello RAP E4
Java package name: org.o7planning.tutorial.rape4

Le projet a été créé :

Exécutez l'application :

Cliquez sur le bouton droite du projet RAPe4Tutorial et sélectionnez :

Run As/Eclipse Application

Le navigateur Eclipse ne peut pas afficher l'application RAP e4.

Vous devez copier le chemin d'accès pour exécuter sur Firefox ou Chrome:

5. Exécuter des configurations

Vous pouvez configurer le port (port) et le navigateur d'exécution des applications RAP e4 par défaut :

Cliquez sur le bouton droit du projet RAPe4Tutorial et sélectionnez :

Run As/Run Configurations...

Utilisez le port 7777 et le navigateur par défaut du système d'exploitation :

Cliquez sur Apply et exécutez l'application :

Les résultats:

6. La structure de l'application Eclipse e4 RAP vide

L'application Eclipse RAP e4 vide a été créé par Eclipse, voyez sa structure. Ouvrez le fichier Application.e4xmi :

Changez le titre de l'application dans "Eclipse E4 RAP Application" comme l'illustration ci-dessous.

Et redémarrez l'application :

7. Configuration supplémentaire des Bundle

Pour créer une application RAP e4 avec de multiples fonctions, vous devez déclarer l'utilisation un des autres Bundle :

Ouvrez le fichier MANIFEST.MF

Ajoutez les Bundle:

org.eclipse.e4.ui.model.workbench
org.eclipse.e4.ui.services
org.eclipse.e4.ui.workbench

Les Bundle peut être indépendants, tel bundle A dépend de bundle de B, C et B dépend de E, F. Si vous ajoutez un bundle dans votre application, Eclipse doit recalculer les Bundle requis pour emballer le produit qui peut fonctionner.

Donc après que vous déclarez l'utilisation d'ajout les Bundle, vous devez reconfigurer l'application.

Cliquez avec le bouton droit sur le projet et sélectionnez:

Run As/Run Configurations

Cliquez sur Add Required Bundles pourque eclipse recalcule les bundle dépendants
Cliquez sur Validate Bundles pour assurer que votre projet a aucun problème

8. Handler et Command

RAP Framework construit un grand nombre de commandes, telle que 3 commandes avec l'ID ci-dessous :

org.eclipse.ui.file.exit
- Commande pour quitter l'application
org.eclipse.ui.file.open
- La commande pour ouvrir un fichier.
org.eclipse.ui.file.save
- La commande save editor
org.eclipse.ui.help.aboutAction
- La commande qui s'ouvre la fenêtre About.

Vous pouvez voir plus une liste de la commande du RCP framework à
http://help.eclipse.org/mars/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/actions/ActionFactory.html

Créez une Command qui est nommée quiteCommand, appelée la commande pour quitter l'application construite par RAP Framework.

De même manière, nous créons deux autres Commands:

Exécutez l'éditeur actif (ou part).

ID: org.eclipse.ui.file.save
Name: saveCommand

AboutCommand:

ID: org.eclipse.ui.help.aboutAction
Name: aboutCommand

Handler est la classe de gestion les Commandes (commande) du Menu ou Toolbar (barre d'outils). Lorsque vous cliquez sur le MenuItem ou ToolItem c'est-à-dire un appel d'exécution d'une Commande. Handler sera exécutée avant l'exécution de la Commande, vous pouvez annuler (annuler) la Commande est exécutée dans Handler.

Lorsque Handler est exécuté, elle va exécuter des tâches qui ont été écrites dans la méthode annotée par @Execute.

Je vais créer trois classes Handler :

AboutHandler.java

package org.o7planning.tutorial.rape4.handler;

import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;

public class AboutHandler {
 
  @Execute
  public void execute(Shell shell) {
      MessageDialog.openInformation(shell, "About", "Eclipse e4 RAP Application");
  }
}

QuitHandler.java

package org.o7planning.tutorial.rcp.handler;

import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.workbench.IWorkbench;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;


public class QuitHandler {
 @Execute
 public void execute(IWorkbench workbench, Shell shell){
     if (MessageDialog.openConfirm(shell, "Confirmation",
             "Do you want to exit?")) {
         workbench.close();
     }
 }
}

SaveHandler.java

package org.o7planning.tutorial.rcp.handler;

import org.eclipse.e4.core.di.annotations.CanExecute;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.workbench.modeling.EPartService;

public class SaveHandler {

 @CanExecute
 public boolean canExecute(EPartService partService) {
     if (partService != null) {
         return !partService.getDirtyParts().isEmpty();
     }
     return false;
 }

 @Execute
 public void execute(EPartService partService) {
     partService.saveAll(false);
 }
}

Déclarez des classes Handler avec des applications.

Lorsque vous déclarez un Handler avec Application, vous devez déclarez ID, Handler class et Command.

Par exemple, les utilisateurs quittent l'application en cliquant sur menuItem Exit, ce MenuItemest associé à quiteCommand.QuiteHandler est la classe de gestion de cette commande (tel que déclaré ci-dessus). La classe QuiteHandler demande aux utilisateurs de vouloir vraiment fermer l'application ou non, si oui la CommandequiteCommand sera exécutée.

Saisissez :

ID: handler.quiteCommand

De même manière, déclarez les autres Handler.

handler.aboutCommand

handler.saveCommand

9. Créer Menus

Ajoutez des icônes sur le projet, utilisé comme symbole de MenuItem et ToolItem.

sample.png
save_edit.png

Créez le menu principal de l'application

Saisissez l'ID du Main Menu, il doit être nommé :

menu:org.eclipse.ui.main.menu

Créez trois sous-menus :

File, Function, Help

Créez le sous-menu au menu Fichier.

Save
Exit

Réexécutez votre application :

10. Créer Toolbar

Créez Main Toolbar avec ID :

ID: toolbar:org.eclipse.ui.main.toolbar

Ajoutez deux Toolitem : open & save( ouvrir et enregistrer )

Réexécutez votre application :

11. Part

SamplePart.java

/*******************************************************************************
* Copyright (c) 2010 - 2013 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
*     IBM Corporation - initial API and implementation
*     Lars Vogel <lars.Vogel@gmail.com> - Bug 419770
*******************************************************************************/
package org.o7planning.tutorial.rape4.part;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

import org.eclipse.e4.ui.di.Focus;
import org.eclipse.e4.ui.di.Persist;
import org.eclipse.e4.ui.model.application.ui.MDirtyable;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Text;

public class SamplePart {

  private Text txtInput;
  private TableViewer tableViewer;

  @Inject
  private MDirtyable dirty;

  @PostConstruct
  public void createComposite(Composite parent) {
      parent.setLayout(new GridLayout(1, false));

      txtInput = new Text(parent, SWT.BORDER);
      txtInput.setMessage("Enter text to mark part as dirty");
      txtInput.addModifyListener(new ModifyListener() {
          @Override
          public void modifyText(ModifyEvent e) {
              dirty.setDirty(true);
          }
      });
      txtInput.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

      tableViewer = new TableViewer(parent);

      tableViewer.add("Sample item 1");
      tableViewer.add("Sample item 2");
      tableViewer.add("Sample item 3");
      tableViewer.add("Sample item 4");
      tableViewer.add("Sample item 5");
      tableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH));
  }

  @Focus
  public void setFocus() {
      tableViewer.getTable().setFocus();
  }

  @Persist
  public void save() {
      dirty.setDirty(false);
  }
}

Ajoutez un nouveau PerspectiveStack. Ceci est un Stack qui contient des perspectives.