To migrate your Views and Editors to Eclipse 4 you can use the org.eclipse.e4.tools.compat plug-in from the e4 tooling projects

To use this bridge in Eclipse 4.2 or Eclipse 3.8 just install the org.eclipse.e4.tools.e3x.bridge feature into your Eclipse IDE.

Afterwards add the following plug-ins to your MANIFEST.MF

You can now develop your Parts as Pojos:

package example.compat.parts;
 
import javax.annotation.PostConstruct;
 
import org.eclipse.e4.ui.di.Focus;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
 
public class Part {
    public static final String ID = "example.compat.view";
 
    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());
        TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
        column.getColumn().setWidth(100);
        column.setLabelProvider(new ColumnLabelProvider(){
            @Override
            public String getText(Object element) {
                return element.toString();
            }
        });
         
        // Provide the input to the ContentProvider
        viewer.setInput(new String[] { "One", "Two", "Three" });
    }
 
    @Focus
    public void setFocus() {
        viewer.getControl().setFocus();
    }
} 

In your plugin.xml you use ViewWrapper to define your Views.

package example.compat;
 
import org.eclipse.e4.tools.compat.parts.DIViewPart;
 
import example.compat.parts.View;
 
public class ViewWrapper extends DIViewPart<View> {
 
    public ViewWrapper() {
        super(Part.class);
    }
 
} 

This way you can use the dependency injection already in your Eclipse 3.x plugin, have a better possibility to test your user interface components in plain JUnit test (they are just POJO) and get ready for a full Eclipse 4 migration.

Mixing Eclipse 4 and Eclipse 3.x. components is currently not officially supported in the Eclipse 4.2 release.

You can however define your own LegacyIDE.e4xmi file and add your model components to this file. Via the applicationXMI parameter in your org.eclipse.core.runtime.products extension point you point to that file.

For this approach you have to copy the standard LegacyIDE.e4xmi file and add your model components to it. This file can be found in the org.eclipse.ui.workbench plug-in.

A code example for this approach can be found under the following URL:

https://github.com/fredrikattebrant/Simple-4x-RCP-app 

While this approach seems to work, it is currently not officially supported in the Eclipse 4.2 release.

If you want to migrate your Eclipse 3.x RCP application to the Eclipse 4 programming model, you can't directly reuse existing plugin.xml based user interface components, e.g. Views or Editors based on the definition in plugin.xml.

Components based on the plugin.xml file must be adjusted to avoid inheritance of Eclipse classes and to use the programming model based on @Inject. They also must be contributed to the application model.

Components which are not directly based on the plugin.xml file must be adjusted if they use Eclipse 3.x singletons, as for example Platform or PlatformUI, to access Eclipse API.

The Eclipse 4 team intends to provide support for such mixed mode hybrid applications in future Eclipse releases.

Please help me to support this article:

Before posting questions, please see the vogella FAQ. If you have questions or find an error in this article please use the www.vogella.com Google Group. I have created a short list how to create good questions which might also help you.

http://wiki.eclipse.org/E4 Eclipse E4 - Wiki

Eclipse RCP

Eclipse EMF

Dependency Injection