Die Anleitung zum Eclipse RCP für den Anfänger - Workbench Anwendung

Die Installation vor dem Beginn
Die Erstellung von Java Workspace
Die Erstelllung von dem leeren Eclipse 4 RCP Projekt
Die Struktur der leeren Applikation Eclipse 4 RCP
Handler und Command
Die Erkläreung von Menus
Die Erstellung von Toolbar
Part

1. Die Installation vor dem Beginn

Das Plugin WindowBuilder installieren, Mit diesem Plugin können Sie die Interface der Applikation SWT durch Ablegen-und-Ziehen sehr einfach entwerfen. Sie können die Installationshinweise bei ... sehen.

Installieren Sie WindowBuilder für Eclipse

Installing e4 Tools Developer Sources:

Installieren Sie e4ToolsDeveloperResources für Eclipse

2. Die Erstellung von Java Workspace

Sie sollen ein Java Workspace neu erstellen um die Applikation RCP zu programmieren

File/Switch Workspace/Other..

Geben Sie ein:

F:\ECLIPSE_TUTORIAL\RCP

3. Die Erstelllung von dem leeren Eclipse 4 RCP Projekt

Im Dokument führe ich Sie bei dem Aufbau einer RCP Applikation seit der Beginn (Nach der vorhandenen Vorlage (template) nich machen). So erstelle ich eine leere Eclipse RCP Applikation

Auf die Eclipse wählen Sie :

File/New/Other...

Klicken Sie auf (1) zu wählen
Auf (2) wählen Sie "Yes" damit Eclipse ein RCP Project (Auf die Desktop laufen) erstellt, umgekehrt erstellt es ein RAP Project (Auf die Web laufen).

Wählen Sie "Eclipse 4 RCP Application"

Geben Sie ein:

Java package name: org.o7planning.tutorial.rcp

Das Project wird erstellt:

Machen Sie Demo für die Applikation

Drücken Sie die Rechtsmaustaste auf EclipseRCPTutorial.product und wählen Sie Run As/Eclipse Application

4. Die Struktur der leeren Applikation Eclipse 4 RCP

Die leere Applikation Eclipse 4 RCP wird durch Eclipse erstellt, bitte sehen Sie ihre Struktur. Öffnen Sie die File von Application.e4xmi:

Ändern Sie die Titel von der Applikation zu "Eclipse E4 RCP Application" wie das folgende Beispiel.

Und starten Sie die Applikation wieder

5. Handler und Command

RCP Framework baut bereit viele Command, wie 4 command mit den folgenden ID:

org.eclipse.ui.file.exit
- Der Befehl zum Austritt der Applikation
org.eclipse.ui.file.open
- Der Befehl zum Öffnen der File.
org.eclipse.ui.file.save
- Der Befehl zum Speichern von editor
org.eclipse.ui.help.aboutAction
- Der Befehl zum Öffnen des Fenster About.

Sie können die Liste von den gereit gebauten Command vom RCP Framework bei... sehen:
http://help.eclipse.org/mars/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/actions/ActionFactory.html

Erstellen Sie ein Command mit den Name von quiteCommand, Rufen Sie den Befehl des Applikationsaustritt auf, der von RCP Framework.bereit gebaut wird

Ähnlich erstellen wir 3 andere Command.

Der Befehl zur Aufruf von Editor zum Öffnen der gewählten File.

ID: org.eclipse.ui.file.open
Name: openCommand

Führen Sie den Befehl der Inhaltspeicherung in Editor durch.

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

AboutCommand:

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

Handler ist die Class für die Behandlung der Befehl (command) vom Menu oder Toolbar. Wenn Sie auf MenuItem oder ToolItem klicken, d.h die Aufruf auf die Implementierung eines Command, bevor das Command implementiert wird,wird Handler vorher implementiert, können Sie die Implementierung des Command im Handler absagen (cancel).

Handler ist die Class, die bei der Implementierung die in Method geschriebenen Tasks, die vom @Execute kommentiert werden, durchführen.

Wir werden 4 Class Handler erstellen

AboutHandler.java

package org.o7planning.tutorial.rcp.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 4 RCP Application");
   }
}

OpenHandler.java

package org.o7planning.tutorial.rcp.handler;

import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;

public class OpenHandler {

   @Execute
   public void execute(Shell shell){
       FileDialog dialog = new FileDialog(shell);
       dialog.open();
   }
}

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);
   }
}

Melden Sie die Class Handler mit der Applikation an

Um einen Handler mit der Applikation anzumelden, sollen Sie ID, Handler class und Command anmelden

Zum Beispiel: Der Benutzer schließt die Applikation durch das Klicken auf das menuItem Exit. Dieses MenuItem bindet mit quiteCommand, QuiteHandler, die als die Behandlungsclass für dieses Command gilt (wie oben anmeldet). Die Class QuiteHandler fragt, ob der Benutzer die Applikation wirklich schließen möchten. Wenn ja, wird das Command quiteCommand durchgeführt.

So ähnlich wie die Anmeldung von anderen Handler.

6. Die Erkläreung von Menus

Erstellen Sie das Hauptmenu von der Applikation (Main menu)

Geben Sie ID vom Main Menu ein, muss es sein: menu:org.eclipse.ui.main.menu

Fügen Sie 3 untergeordnete Menu ein

File, Function, Help

Melden Sie die untergeordneten Menu für Menu File an

Open
Save
Exit

Sie können Ihre Applikation wieder starten

7. Die Erstellung von Toolbar

Erstellen Sie Main Toolbar mit ID

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

Fügen Sie 2 Toolitem: open & save ein

Starten Sie Ihre Applikation wieder

8. 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.rcp.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);
    }
}

Erstellen Sie PerspectiveStack. Das ist der Stapel (Stack) von der Aussicht (Perspective).