An Eclipse application consists of several Eclipse components. A software component in Eclipse is called a plug-in. The Eclipse platform allows the developer to extend Eclipse applications like the Eclipse IDE with additional functionalities via plug-ins.

Eclipse applications use a runtime based on a specification called OSGi. A software component in OSGi is called a bundle but a bundle is also always a plug-in. Both terms can be used interchangeably. A software component in Eclipse is called a plug-in.

For example a new plug-in can create new menu entries or toolbar entries.

The Eclipse platform forms the basis of the most successful Java IDE and therefore is very stable and broadly used. It uses native user interface components which are fast and reliable. It has a strong modular approach based on the industry standard module system for Java (OSGi) that allows developers to design component based systems.

Companies such as IBM, SAP and Google use the Eclipse framework as a basis for their products and therefore need to ensure that Eclipse is flexible, fast and continues to evolve.

The Eclipse platform also fosters a large community of individuals which provide support, documentation and extensions to the Eclipse framework. Tapping into this ecosystem allows you to find required resources and information.

The Eclipse IDE version 2.0 started as a modular IDE application. In 2004 Eclipse version 3.0 was released. Eclipse 3.0 supported reusing components of the Eclipse platform to build stand-alone applications based on the same technology as the Eclipse IDE.

At this point the term Eclipse RCP was coined. Eclipse RCP is short for Eclipse Rich Client Platform and indicates that the Eclipse platform is used as a basis to create feature-rich stand-alone applications.

The release of Eclipse in version 4.x simplified and unified the Eclipse programming model which is now based on state-of-the-art technologies, like dependency injection and declarative styling via CSS files.

Eclipse RCP applications benefit from the existing user interface and the internal framework, and can reuse existing plug-ins and features.

This tutorial assumes that you are already familiar with standard Java development and with the Eclipse IDE.

See Eclipse Model Spy to learn abou the model spy.

After you downloaded the file with the Eclipse distribution, unpack it to a local directory. Most operating systems can extract zip or tar.gz files in their file browser (e.g., Windows 7) with a right-click on the file and selecting "Extract all...".

Extract Eclipse to a directory without spaces in its path and do not use a mapped network drive (Windows). Also avoid path names longer than 255 characters under Microsoft Windows. Installations of the Eclipse IDE sometimes have problems with such a setup.

After you extracted the compressed file you can start Eclipse, no additional installation procedure is required.

A common error is that the user downloads a 32 or a 64 bit version of Eclipse but tries to start it on a 64 or 32 JVM. Both versions must fit together as Eclipse contains native code. Unfortunately you can run a 32 bit JVM on a 64 bit operating system. Use java -version on the command line and if the output does not contain the word "Server" you are using the 32 bit version of Java and must use a 32 bit version of Eclipse.

Menus, handlers and commands can be contributed to an Eclipse application via model fragments. For this you only need to know the ID of the element to which you want to contribute. The ID of the Eclipse IDE and Eclipse 3.x RCP applications is hard coded to the org.eclipse.e4.legacy.ide.application value.

With the correct ID you can create model fragments that contribute to the corresponding application model element. This is demonstrated by the following screenshots.

The Parent-ID must be the ID of the menu your are contributing to.

The model fragment must be registered in the plugin.xml file via an extension to the org.eclipse.e4.workbench.model extension point, as demonstrated in the following listing.

<?xml version="1.0" encoding="UTF-8"?>
<plugin>
   <extension
         id="id1"
         point="org.eclipse.e4.workbench.model">
      <fragment
            apply="notexists"
            uri="fragment.e4xmi">
      </fragment>
   </extension>

</plugin> 

Similar to menus you can contribute toolbar contributions. This is demonstrated in Section 7.7, “Adding a toolbar contribution”.

In this exercise you create a plug-in which contributes an e4 menu entry to a 3.x based application menu.

Create a new plug-in project called com.vogella.plugin.first via File → New → Project... → Plug-in Development → Plug-in Project.

Enter the data as depicted in the following screenshots.

Press the Next button.

Press the Next button.

Select the Hello, World Command template and press the Next button. This template uses the 3.x API, which you convert to the e4 API in Section 7.6, “Creating a model contribution”.

The last page of the wizard allows you to customize the values of the wizard. You can leave the default values and press the Finish button.

Eclipse may ask you if you want to switch to the plug-in development perspective. Answer Yes if you are prompted.

As a result the following project is created.

Start a new Eclipse IDE instance and validate that your menu and toolbar entry is available. See ??? for more information on how to start an instance of the Eclipse IDE with your new plug-in.

A new Eclipse IDE starts, which has your new menu entry included. If you select this menu entry, a message box is displayed.

Add a dependency to the org.eclipse.e4.core.di plug-in in the manifest file of the newly created plug-in.

Create the following class based on the generated handler class.

package com.vogella.plugin.first.handlers;

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

public class SampleE4Handler {

  @Execute
  public void execute(Shell shell) {
    MessageDialog.openInformation(shell, "First", "Hello, e4 API world");
  }
} 

Select New → Other... → Eclipse 4 → Model → New Model Fragment from the context menu of the plug-in project.

Press the Finish button.

Create three model fragment entries in your new file, all of them should be contributing to the org.eclipse.e4.legacy.ide.application element id.

Use the following screenshots to define the new contribution.

Also add a toolbar contribution for the same command.

Add a toolbar and a handled tool item to your contribution.

Start a new instance of the Eclipse IDE and validate that your menu and the toolbar are is contributed. If they are not visible in the window, check via the model spy for potential issues.

You have several options to make your plug-in available in your Eclipse IDE. You can:

You can install your plug-in directly into your running Eclipse IDE.

The Eclipse plug-in export wizard has an option for this. Open the export wizard via File → Export → Plug-in Development → Deployable plug-ins and fragments.

In the export wizard dialog select in this case Install into host. Repository. This is depicted in the following screenshot.

If you export your plug-in locally, you can put it into the Eclipse dropins folder of your Eclipse installation. After a restart of your Eclipse your plug-in should be available and ready for use.

Open again the export wizard via File → Export → Plug-in Development → Deployable plug-ins and fragments.

Select the plug-in you want to export and the folder to which this plug-in should get exported.

Press the Finish button. This creates a JAR file with the exported plug-in in the selected directory.

Copy this JAR file to the dropins directory in your Eclipse installation directory and restart your running Eclipse.

After this restart your new plug-in is available in your Eclipse installation and ready to be used.

You can create an update site for your plug-in. An update site consists of static files which can be placed on a file server or a web server. Other users can install Eclipse plug-in from this update site by providing them a link to the update site.

This requires that you create a feature project for the plug-in. You can export this feature project and use the Eclipse update manager to install the feature (with the plug-in).

By default, the Eclipse update manager shows only features with a category. Therefore, you should always include a category for your exported feature to make it easy for the user to install your feature.

Create a feature project for your plug-in and add your plug-in to this feature. You create a feature project via File → New → Other... → Plug-in Development → Feature Project.

Create the feature project similar to the following screenshots.

In your feature project create via the menu entry File → New → Other... → Plug-in development → Category Definition a new category definition.

Press the New Category button and create a category with a name which describes your functionality. Add your feature to this category.

You can create an update site for your feature in a local directory on your machine. For this, select File → Export → Deployable features.

To use your category, switch to the Options tab and select the path to your category.xml file in the Categorize repository option.

Use the Eclipse update manager via Help → Install New Software... to install this new feature into your Eclipse IDE.

Use the update manager and point to your local directory and select and install your feature. In case you don't see your feature, try deselecting the Group items by category flag. In this case you have forgotten to use your category during the export.

Restart the Eclipse IDE after the installation. Ensure that your plug-in is available in your Eclipse installation and can be used.

As a reminder, the term POJO (Plan Old Java Object) is used to describe a Java class without inheritance of a framework class.

As of the Eclipse 4.4 release you can also use a POJO in an extension for the org.eclipse.ui.views extension point. Use the e4view entry in the context menu of the extension to archive this. The resulting object is created via dependency injection.

For such a kind of view the existing toolbar and view extension point contributions do not work. To add for example a toolbar to your e4view, get the MToolbar injected into its implementation and construct the entries in your source code.

The Eclipse 4.5 IDE release will support the contribution of part descriptor model elements via fragments or processors.

If you use the org.eclipse.e4.legacy.ide.application ID to contribute your part descriptors, the views can be opened via the Window → Show View → Other... dialog or via the Quick Access. This requires that you add the View tag to such a part descriptor.

Eclipse 3.x API RCP applications running on top of a 4.5 or higher runtime can use the same approach.

Your model fragment or processor can also contribute a perspective to an Eclipse 4.x IDE. For this add a perspective via a snippet. This snippet must again contribute to the application via the org.eclipse.e4.legacy.ide.application ID.

This approach can also be used to contribute a perspective to your Eclipse 3.x API based RCP application running on top of an Eclipse 4.x runtime but this depends on the specifics of your application.

In this exercise you create an Eclipse 3.x RCP application and add a POJO part to it based on the e4view element available to contribute an extension point based view.

Create an Eclipse 3.x RCP application based on the RCP application with a view template via File → New → Other... → Plug-in Project. Call the project com.vogella.rcp.eclipse3x.e4view and select the options similar to the following screenshots.

Add org.eclipse.e4.ui.di as a dependency to the manifest of your new plug-in.

Create the following class.

package com.vogella.rcp.eclipse3x.e4view;

import javax.annotation.PostConstruct;

import org.eclipse.e4.ui.di.Focus;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;

public class ViewEclipse4x  {
  private TableViewer viewer;

  @PostConstruct
  public void createPartControl(Composite parent) {
    viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
        | SWT.V_SCROLL);
    viewer.setContentProvider(ArrayContentProvider.getInstance());
    viewer.setLabelProvider(new LabelProvider());
    viewer.setInput(new String[] {"One", "Two", "Three"});
  }

  @Focus
  public void setFocus() {
    viewer.getControl().setFocus();
  }
} 

Afterwards add an e4view extension for the org.eclipse.ui.views extension point. For this use the Extensions tab of the plugin.xml editor.

To be able to see the new view, add it to the existing perspective extension as depicted in the following screenshot.

Start your Eclipse 3.x application and validate that the new part is displayed.

In this exercise you add a model based part contribution to an Eclipse 3.x RCP application.

Create a simple plug-in called com.vogella.plugin.partdescriptor.

Add the following dependencies to your manifest file.

Create the following class

package com.vogella.plugin.partdescriptor;

import javax.annotation.PostConstruct;

import org.eclipse.e4.ui.di.Focus;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;

public class PartEclipse4x  {
  private TableViewer viewer;

  @PostConstruct
  public void createPartControl(Composite parent) {
    viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
        | SWT.V_SCROLL);
    viewer.setContentProvider(ArrayContentProvider.getInstance());
    viewer.setLabelProvider(new LabelProvider());
    viewer.setInput(new String[] {"One", "Two", "Three"});
  }

  @Focus
  public void setFocus() {
    viewer.getControl().setFocus();
  }
} 

Add a new model fragment to this plug-in via File → New → Other... → Eclipse 4 → Model → New Model Fragment.

Start an instance of the Eclipse IDE and validate that you can open the parts via the Quick Access box (shortcut Ctrl+3).

In this example we will add a new context menu entry to the Package Explorer part. The context menu is displayed if the user selects a file in the package explorer via a right mouse click. We will offer the option to create a HTML page from a Java source file.

To contribute to an existing menu or toolbar, you need to know the corresponding ID. This ID can be found via the Menu Spy. To start the Menu Spy use ALT + Shift + F2 and click on the menu entry you are interested in.

Create a new plug-in project called de.vogella.plugin.htmlconverter. Do not use a template.

Open the META-INF/MANIFEST.MF file. Select the Dependencies tab and add the following dependencies to your plug-in.

Open the Extensions tab in your editor, or if the tab is not visible, click the Extensions link on the Overview tab. Add a command with the ID de.vogella.plugin.htmlconverter.convert and the default handler de.vogella.plugin.htmlconverter.handler.ConvertHandler to your plug-in.

Add this command to the menu via the extension point org.eclipse.ui.menus and use popup:org.eclipse.jdt.ui.PackageExplorer as the locationURI. Set the label to Create HTML for this contribution.

The resulting file plugin.xml should look like the following.

<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
  <extension point="org.eclipse.ui.menus">
    <menuContribution locationURI="popup:org.eclipse.jdt.ui.PackageExplorer">
      <command commandId="de.vogella.plugin.htmlconverter.convert"
        label="Create HTML" style="push">
      </command>
    </menuContribution>
  </extension>
  <extension point="org.eclipse.ui.commands">
    <command defaultHandler="de.vogella.plugin.htmlconverter.handler.ConvertHandler"
      id="de.vogella.plugin.htmlconverter.convert" name="Convert">
    </command>
  </extension>

</plugin> 

Eclipse allows to save additional information for each file. You can use the IResource interface and the setPersistentProperty() and getPersistentProperty() methods. With these functions you can save Strings on files. We use these functions to save a directory for Java source files which were already exported via HTML.

Create the following ConvertHandler class.

package de.vogella.plugin.htmlconverter.handler;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.handlers.HandlerUtil;

public class ConvertHandler extends AbstractHandler {
  private QualifiedName path = new QualifiedName("html", "path");

  @Override
  public Object execute(ExecutionEvent event) throws ExecutionException {
    Shell shell = HandlerUtil.getActiveShell(event);
    ISelection sel = HandlerUtil.getActiveMenuSelection(event);
    IStructuredSelection selection = (IStructuredSelection) sel;

    Object firstElement = selection.getFirstElement();
    if (firstElement instanceof ICompilationUnit) {
      createOutput(shell, firstElement);

    } else {
      MessageDialog.openInformation(shell, "Info",
          "Please select a Java source file");
    }
    return null;
  }

  private void createOutput(Shell shell, Object firstElement) {
    String directory;
    ICompilationUnit cu = (ICompilationUnit) firstElement;
    IResource res = cu.getResource();
    boolean newDirectory = true;
    directory = getPersistentProperty(res, path);

    if (directory != null && directory.length() > 0) {
      newDirectory = !(MessageDialog.openQuestion(shell, "Question",
          "Use the previous output directory?"));
    }
    if (newDirectory) {
      DirectoryDialog fileDialog = new DirectoryDialog(shell);
      directory = fileDialog.open();

    }
    if (directory != null && directory.length() > 0) {
      setPersistentProperty(res, path, directory);
      write(directory, cu);
    }
  }

  protected String getPersistentProperty(IResource res, QualifiedName qn) {
    try {
      return res.getPersistentProperty(qn);
    } catch (CoreException e) {
      return "";
    }
  }

  protected void setPersistentProperty(IResource res, QualifiedName qn,
      String value) {
    try {
      res.setPersistentProperty(qn, value);
    } catch (CoreException e) {
      e.printStackTrace();
    }
  }

  private void write(String dir, ICompilationUnit cu) {
    try {
      cu.getCorrespondingResource().getName();
      String test = cu.getCorrespondingResource().getName();
      // Need
      String[] name = test.split("\\.");
      String htmlFile = dir + "\\" + name[0] + ".html";
      FileWriter output = new FileWriter(htmlFile);
      BufferedWriter writer = new BufferedWriter(output);
      writer.write("<html>");
      writer.write("<head>");
      writer.write("</head>");
      writer.write("<body>");
      writer.write("<pre>");
      writer.write(cu.getSource());
      writer.write("</pre>");
      writer.write("</body>");
      writer.write("</html>");
      writer.flush();
    } catch (JavaModelException e) {
    } catch (IOException e) {
      e.printStackTrace();
    }

  }
} 

If you start this plug-in, you should be able to create HTML output from a Java source file.

Currently our context menu is displayed all the time. We would like to show it only if a source file is selected. For this we will use a "visible-when" definition.

Add the org.eclipse.core.expressions plug-in as dependency to your plug-in. Select your menu contribution. Using the right mouse add the condition to the command that it should only be visible if a file is selected which represents a ICompilationUnit from the org.eclipse.jdt.core package.

For this exercise you use the predefined variable activeMenuSelection which contains the selection in the menu and iterate over it. If the selection can get adapted to ICompilationUnit, then the contribution will be visible.

This will result in the following plugin.xml.

<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="popup:org.eclipse.jdt.ui.PackageExplorer">
         <command
               commandId="de.vogella.plugin.htmlconverter.convert"
               label="Create HTML"
               style="push">
            <visibleWhen
                  checkEnabled="false">
               <with
                     variable="activeMenuSelection">
                  <iterate
                        ifEmpty="false"
                        operator="or">
                     <adapt
                           type="org.eclipse.jdt.core.ICompilationUnit">
                     </adapt>
                  </iterate>
               </with>
            </visibleWhen>
         </command>
      </menuContribution>
   </extension>
   <extension
         point="org.eclipse.ui.commands">
      <command
            defaultHandler="de.vogella.plugin.htmlconverter.handler.Convert"
            id="de.vogella.plugin.htmlconverter.convert"
            name="Convert">
      </command>
   </extension>

</plugin> 

If you now start your plug-in, the menu entry should only be visible if at least one compilation unit has been selected.

Adapters help to display information about objects in view without having to adjust the existing views. In this example we will create a small view which allows to select objects and use the properties view to display them.

Adapters are used on several places, for example, you can use an adapter to display your data in the outline view. See Outline View Example for an example on how to do this.

We will simply use an adapter to show our data in the property view. Create a new plug-in project de.vogella.plugin.adapter. Use the Plug-in with a view template with the following settings.

Add the dependency org.eclipse.ui.views in tab dependencies of plugin.xml.

Create the following data model.

package de.vogella.plugin.adapter.model;

public class Todo {
  private String summary;
  private String description;
  public String getSummary() {
    return summary;
  }
  public void setSummary(String summary) {
    this.summary = summary;
  }
  public String getDescription() {
    return description;
  }
  public void setDescription(String description) {
    this.description = description;
  }

} 

Change the code of SampleView.java to the following. After this change, you should be able to run your project, open your view and see your to-do items.

package de.vogella.plugin.adapter.views;

import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

import de.vogella.plugin.adapter.model.Todo;

public class SampleView extends ViewPart {
  public static final String ID = "de.vogella.plugin.adapter.views.SampleView";

  private TableViewer viewer;

  class ViewLabelProvider extends LabelProvider implements
      ITableLabelProvider {
    public String getColumnText(Object obj, int index) {
      Todo todo = (Todo) obj;
      return todo.getSummary();
    }

    public Image getColumnImage(Object obj, int index) {
      return getImage(obj);
    }

    public Image getImage(Object obj) {
      return PlatformUI.getWorkbench().getSharedImages()
          .getImage(ISharedImages.IMG_OBJ_ELEMENT);
    }
  }

  
/**
   * This is a callback that will allow us to create the viewer and initialize
   * it.
   */
  public void createPartControl(Composite parent) {
    viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
        | SWT.V_SCROLL);
    viewer.setContentProvider(new ArrayContentProvider());
    viewer.setLabelProvider(new ViewLabelProvider());
    getSite().setSelectionProvider(viewer);
    viewer.setInput(getElements());

  }

  
/**
   * Passing the focus request to the viewer's control.
   */
  public void setFocus() {
    viewer.getControl().setFocus();
  }

  // Build up a simple data model
  private Todo[] getElements() {
    Todo[] todos = new Todo[2];
    Todo todo = new Todo();
    todo.setSummary("First Todo");
    todo.setDescription("A very good description");
    todos[0] = todo;
    todo = new Todo();
    todo.setSummary("Second Todo");
    todo.setDescription("Second super description");
    todos[1] = todo;
    return todos;
  }
} 

To displays its values in the property view, add the extension point org.eclipse.core.runtime.adapters to your project. The data of the extension point should be like the following.

<extension
         point="org.eclipse.core.runtime.adapters">
      <factory
            adaptableType="de.vogella.plugin.adapter.model.Todo"
            class="de.vogella.plugin.adapter.TodoAdapterFactory">
         <adapter
               type="org.eclipse.ui.views.properties.IPropertySource">
         </adapter>
      </factory>
</extension> 

Implement the factory and the new class TodoPropertySource which implements IPropertySource.

package de.vogella.plugin.adapter;

import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.ui.views.properties.IPropertySource;

import de.vogella.plugin.adapter.model.Todo;

public class TodoAdapterFactory implements IAdapterFactory {

  @Override
  public Object getAdapter(Object adaptableObject, Class adapterType) {
    if (adapterType== IPropertySource.class && adaptableObject instanceof Todo){
      return new TodoPropertySource((Todo) adaptableObject);
    }
    return null;
  }

  @Override
  public Class[] getAdapterList() {
    return new Class[] { IPropertySource.class };
  }

} 

package de.vogella.plugin.adapter;

import org.eclipse.ui.views.properties.IPropertyDescriptor;
import org.eclipse.ui.views.properties.IPropertySource;
import org.eclipse.ui.views.properties.TextPropertyDescriptor;

import de.vogella.plugin.adapter.model.Todo;

public class TodoPropertySource implements IPropertySource {

  private final Todo todo;

  public TodoPropertySource(Todo todo) {
    this.todo = todo;
  }


  @Override
  public boolean isPropertySet(Object id) {
    return false;
  }

  @Override
  public Object getEditableValue() {
    return this;
  }

  @Override
  public IPropertyDescriptor[] getPropertyDescriptors() {

    return new IPropertyDescriptor[] {
        new TextPropertyDescriptor("summary", "Summary"),
        new TextPropertyDescriptor("description", "Description") };
  }

  @Override
  public Object getPropertyValue(Object id) {
    if (id.equals("summary")) {
      return todo.getSummary();
    }
    if (id.equals("description")) {
      return todo.getDescription();
    }
    return null;
  }

  @Override
  public void resetPropertyValue(Object id) {

  }

  @Override
  public void setPropertyValue(Object id, Object value) {
    String s = (String) value;
    if (id.equals("summary")) {
      todo.setSummary(s);
    }
    if (id.equals("description")) {
      todo.setDescription(s);
    }
  }

} 

If you run your workbench and open your view via Windows → Show → View → Others → Sample Category → Sample View and if you select a data element in your viewer you should see your data in the Properties view.

Please consider a contribution if this article helped you. It will help to maintain our content and our Open Source activities.

Writing and updating these tutorials is a lot of work. If this free community service was helpful, you can support the cause by giving a tip as well as reporting typos and factual errors.

If you find errors in this tutorial, please notify me (see the top of the page). Please note that due to the high volume of feedback I receive, I cannot answer questions to your implementation. Ensure you have read the vogella FAQ as I don't respond to questions already answered there.

This tutorial is Open Content under the CC BY-NC-SA 3.0 DE license. Source code in this tutorial is distributed under the Eclipse Public License. See the vogella License page for details on the terms of reuse.

Source Code of Examples