xtending the Eclipse IDE - Plug-in development - Tutorial
Version 2.7
Copyright © 2007-2015 vogella GmbH
08.03.2015
Table of Contents
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. An OSGi bundle is also always an Eclipse 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.
The Eclipse IDE is basically an Eclipse RCP application to support development activities. Even core functionality of the Eclipse IDE is provided via a plug-in, for example the Java development or the C development tools are contributed as a set of plug-ins. Only if these plug-ins are present the Java or C development capabilities are available.
The Eclipse IDE functionality is heavily based on the concept of extensions and extension points. For example the Java Development Tools provide an extension point to register new code templates for the Java editor.
Via additional plug-ins you can contribute to an existing functionality, for example new menu entries, new toolbar entries or provide completely new functionality. But you can also create completely new programming environments.
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.
If you plan to add functionalities to the Eclipse platform, you should download the latest Eclipse release. Official releases have stable APIs, therefore are a good foundation for adding your plug-ins and features.
The Eclipse IDE is provided in different flavors. While you can install the necessary tools in any Eclipse package, it is typically easier to download the Eclipse Standard distribution which contains all necessary tools for plug-in development. Other packages adds more tools which are not required for Eclipse plug-in development.
Browse to the Eclipse download site and download the Eclipse Standard package.
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 into a directory with no spaces in its path, and do not use mapped network drives. Also avoid to have path names longer than 255 characters. Installations of Eclipse in directories with long path names might cause problems, as some Microsoft Windows tooling can not manage these long path names.
After you extracted the compressed file you can start Eclipse, no additional installation procedure is required.
A common startup error happens when the user tries to launch a 64-bit version of Eclipse using a 32 bit JVM or vice versa. In this case Eclipse does not start and the user gets a message containing exit code=13. This happens when the version of Eclipse is not matching the JVM version. A 32-bit Eclipse must run with Java 32 bit, and 64-bit Eclipse must use a 64-bit JVM. 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. To do 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. The following screenshot demonstrate how to contribute to the menuContributions feature of the Eclipse IDE.
After you added a MenuContribution item you can contribute a menu. 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.modelextension 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>
In case of problems, check the source code of plugin.xml and validate that your model fragment is included. Verify the name of the referred model fragment and ensure all the defined ID are available in the running configuration.
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 → → → → .
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”.
In the last page of the wizard you can customize some suggested values. You can leave the default values and press the 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 are available. See ??? for more information on how to start an instance of the Eclipse IDE with additional plug-ins.
After launching the Eclipse IDE instance, you see the sample menu, contributed by your plug-in. After clicking the menu entry, you see a message box.
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 → → → → 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 theorg.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.
You have several options to make your plug-in available in your Eclipse IDE. You can:
Install your plug-in directly into your current Eclipse installation, using your Eclipse IDE. This option is useful for a quick installation and a test during development.
Export your plug-in and copy it into the
dropinsfolder of your Eclipse installation. This option is useful for a simple distribution scenario, where you only have to provide the exported plug-in to your users. On the other hand it is not very convenient for the end user as it requires manual file copying and provides no simple way to update the plug-in.Create an update site and use the Eclipse update manager to install it from this site. This is the simplest approach for the end user. It also allows providing updates to all interested users.
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 → → → .
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 → → → .
Select the plug-in you want to export and the folder to which this plug-in should get exported.
Press the 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 included into a category. Therefore, you should always use 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 → → → → .
Create the feature project according to the following screenshots.
You can create an update site for your feature in a local directory on your machine. For this, select → →.
To use your category, switch to the Options tab and select the path to your category.xml file in the Categorize repositoryoption.
Use the Eclipse update manager via → to install this new feature into your Eclipse IDE.
Use the update manager to point to your local directory. Then 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 set your category during the export.
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 → → 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 → → →. 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 theplugin.xml editor.
To be able to see the new view, add it to the existing perspective extension as depicted in the following screenshot.
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.
-
org.eclipse.core.runtime
-
org.eclipse.jface
-
org.eclipse.e4.ui.model.workbench
-
org.eclipse.e4.ui.di
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 → → → → → .
Similar to Section 6, “Adding e4 commands, menus and toolbars to a 3.x API based applications” you can add model add-ons to your Eclipse 3.x application. This allows you to register for the event service.
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.
-
org.eclipse.jdt.core
-
org.eclipse.core.runtime
-
org.eclipse.core.resources
-
org.eclipse.core.expressions
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 handlerde.vogella.plugin.htmlconverter.handler.ConvertHandler to your plug-in.
Add this command to the menu via the extension point org.eclipse.ui.menus and usepopup: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 thesetPersistentProperty() 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 aICompilationUnit 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.
The Eclipse 4.x IDE uses the IEclipseContext data structure to store central information about the IDE. You can access this information also via the Eclipse 3.x API. This approach is demonstrated with the following snippets. These code snippets assume that you are familiar with the 3.x API, if that is not the case you can skip this section.
For example, to access the context from an Eclipse 3.x API view, you can use the following snippet.
// get the context of a part IEclipseContext partContext = (IEclipseContext) getViewSite().getService(IEclipseContext.class); // or access directly a value in the context based on its key EModelService service = (EModelService) getViewSite().getService(EModelService.class);
This snippet demonstrates the access via an Eclipse 3.x API handler.
// the following example assumes you are in a handler // get context from active window IEclipseContext windowCtx = (IEclipseContext) HandlerUtil.getActiveWorkbenchWindow(event). getService(IEclipseContext.class); // get context from active part IEclipseContext ctx = (IEclipseContext) HandlerUtil.getActivePart(event). getSite().getService(IEclipseContext.class);
Eclipse represents Resources like Projects, Files, Folders, Packages as IResource.
Marker represent additional information for resources, e.g., an error marker. Every marker can have attributes (key / value combination). Markers can be displayed in the standard view, e.g., the Task, Bookmark or the Problems view. To be displayed in these views, you have to use predefined attributes.
The following will demonstrate how to create marker for a selected resource.
Create a plug-in project "de.vogella.plugin.markers". Add the dependency to org.eclipse.core.resources", "org.eclipse.jdt.core" and "org.eclipse.jdt.ui". Create the command "de.vogella.plugin.markers.AddMarker" with the default handler AddMarkerHandler in the de.vogella.plugin.markers.handler class and add this command to the menu.
Create the following code.
package de.vogella.plugin.markers.handler; import org.eclipse.core.commands.AbstractHandler; import org.eclipse.core.commands.ExecutionEvent; import org.eclipse.core.commands.ExecutionException; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IResource; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.ui.handlers.HandlerUtil; public class AddMarker extends AbstractHandler { @Override public Object execute(ExecutionEvent event) throws ExecutionException { IStructuredSelection selection = (IStructuredSelection) HandlerUtil .getActiveSite(event).getSelectionProvider().getSelection(); if (selection == null) { return null; } Object firstElement = selection.getFirstElement(); if (firstElement instanceof IJavaProject) { IJavaProject type = (IJavaProject) firstElement; writeMarkers(type); } return null; } private void writeMarkers(IJavaProject type) { try { IResource resource = type.getUnderlyingResource(); IMarker marker = resource.createMarker(IMarker.TASK); marker.setAttribute(IMarker.MESSAGE, "This a a task"); marker.setAttribute(IMarker.PRIORITY, IMarker.PRIORITY_HIGH); } catch (Exception e) { e.printStackTrace(); } } }
If you run, you can create a marker in the TODO list if you select a Java project and click your menu entry.
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. SeeOutline 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 projectde.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 → → → → → and if you select a data element in your viewer you should see your data in the Properties view.
You can register IResourceChangeListener on resources in Eclipse. For example, if you have a project, you can add or remove a resource listener to or from it.
// add listener project.getWorkspace().addResourceChangeListener(listener); // Remove listener project.getWorkspace().removeResourceChangeListener(listener); // Example resource listener private IResourceChangeListener listener = new IResourceChangeListener() { public void resourceChanged(IResourceChangeEvent event) { if (event.getType() == IResourceChangeEvent.PRE_CLOSE || event.getType() == IResourceChangeEvent.PRE_DELETE) { if (event.getResource().equals(project)) { // Project deleted or closed // do something } return; } if (resource == null) return; IResourceDelta delta = event.getDelta().findMember(new Path(resource.getURI().toPlatformString(false))); if (delta == null) { return; } if (delta.getKind() == IResourceDelta.REMOVED) { // Resource delete // do something } } };
The Eclipse platform provides the org.eclipse.ui.startup extension point via the org.eclipse.ui plug-in.
To implement an extension to this extension point, select on the Extensions tab of the plugin.xml editor and point to a class implementing the IStartup interface.
http://wiki.eclipse.org/Eclipse_Plug-in_Development_FAQ Eclipse Plug-in Development FAQ
http://www.eclipse.org/articles/article.php?file=Article-Adapters/index.html Adapters in Eclipse
扫一扫
223
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
